/*
 * wk2xxx.c
 */

#include "wk2xxx.h"

// #define WK2124 
#define WK2114 

///                            移植修改区域

#define WK2124_RST1_GPIO_Port 	GPIOA
#define WK2124_RST1_Pin 		GPIO_PIN_15
#define WK2124_CS1_GPIO_Port 	GPIOA
#define WK2124_CS1_Pin 			GPIO_PIN_15
// 拉低RST引脚
#define WK_GPIO_RST_L()    HAL_GPIO_WritePin( WK2124_RST1_GPIO_Port, WK2124_RST1_Pin, GPIO_PIN_RESET )
// 拉高RST引脚
#define WK_GPIO_RST_H()    HAL_GPIO_WritePin( WK2124_RST1_GPIO_Port, WK2124_RST1_Pin, GPIO_PIN_SET )

#ifdef WK2124
#include "spi.h"
#define WK_SPI_Handle ( &hspi2 )
#endif 
 
#ifdef WK2114
#include "usart.h"
#define WK_Uart_Handle ( &huart2 )
#endif 
 
// 片选引脚 拉低 拉高
#ifdef WK2124 
#define WK_GPIO_SEL_L()   HAL_GPIO_WritePin( WK2124_CS1_GPIO_Port, WK2124_CS1_Pin, GPIO_PIN_RESET ) 
#define WK_GPIO_SEL_H()   HAL_GPIO_WritePin( WK2124_CS1_GPIO_Port, WK2124_CS1_Pin, GPIO_PIN_SET ) 
#endif 
 
#ifdef WK2114
#define WK_GPIO_SEL_L()    
#define WK_GPIO_SEL_H()    
#endif


static void wk_delay_ms(uint32_t nms)
{
    HAL_Delay(nms);
}

static uint8_t WK_SPI_ReadWriteByte(uint8_t TxData)
{
    uint8_t RxData = 0X00;
#ifdef WK2124
    if ( HAL_SPI_TransmitReceive(WK_SPI_Handle, &TxData, &RxData, 1, 10) != HAL_OK )
    {
        RxData = 0XFF;
    }
#endif
#ifdef WK2114
	/*  ????  */
    if ( HAL_Uart_Transmit(WK_Uart_Handle, &TxData, 1, 10) != HAL_OK )
    {
        RxData = 0XFF;
    }
    if ( HAL_UART_Receive(WK_Uart_Handle, &RxData, 1, 100) != HAL_OK )
    {
        RxData = 0XFF;
    }	
#endif
    return RxData;
}

///                            驱动程序代码

void WK_Port(void)
{
	/* Hard Reset */
	WK_Rst();

	/* uart 需要自适应串口, spi无需此操作*/
	WK_SPI_ReadWriteByte( 0x55 );
	
	// init ports
	WK_PortInit(1, 11059200, 9600);  // 晶振 = 11.0592MHz ，这个值根据实际进行修改
	WK_PortInit(2, 11059200, 9600);
	WK_PortInit(3, 11059200, 9600);
	WK_PortInit(4, 11059200, 9600);

}

/// 硬件复位（拉低复位引脚最低10毫秒进行复位）
void WK_Rst(void)
{
	WK_GPIO_RST_L( );
	wk_delay_ms( 50 );
	WK_GPIO_RST_H( );
	wk_delay_ms( 50 );
}

void WK_WriteGReg( uint8_t reg, uint8_t value )
{
	WK_GPIO_SEL_L( );
	WK_SPI_ReadWriteByte( reg );
	WK_SPI_ReadWriteByte( value );
	WK_GPIO_SEL_H( );
}

uint8_t WK_ReadGReg( uint8_t reg )
{
	uint8_t value = 0X00;
	WK_GPIO_SEL_L( );
	WK_SPI_ReadWriteByte( 0X40 | reg );
	value = WK_SPI_ReadWriteByte( 0X00 );
	WK_GPIO_SEL_H( );
	return value;
}

void WK_WriteSReg( uint8_t port, uint8_t reg, uint8_t value )
{
	WK_GPIO_SEL_L( );
	WK_SPI_ReadWriteByte( ((port - 1) << 4) | reg );
	WK_SPI_ReadWriteByte( value );
	WK_GPIO_SEL_H( );
}

uint8_t WK_ReadSReg( uint8_t port, uint8_t reg )
{
	uint8_t value = 0X00;
	WK_GPIO_SEL_L( );
	WK_SPI_ReadWriteByte(0X40 | ((port - 1) << 4) | reg);
	value = WK_SPI_ReadWriteByte( 0X00 );
	WK_GPIO_SEL_H( );
	return value;
}

void WK_WriteFIFO( uint8_t port, const void* buf, uint16_t len )
{
	const uint8_t* p = (const uint8_t *)buf;
	WK_GPIO_SEL_L( );
	WK_SPI_ReadWriteByte(0X80 | ((port - 1) << 4));
	while (len--)
	{
		WK_SPI_ReadWriteByte(*p++);
	}
	WK_GPIO_SEL_H( );
}

void WK_ReadFIFO( uint8_t port, void* buf, uint16_t len )
{
	uint8_t* p = (uint8_t *)buf;
	WK_GPIO_SEL_L( );
	WK_SPI_ReadWriteByte(0XC0 | ((port - 1) << 4));
	while (len--)
	{
		*p++ = WK_SPI_ReadWriteByte(0X00);
	}
	WK_GPIO_SEL_H( );
}

void WK_PortCalcBaudrate( uint32_t fosc, uint32_t baudrate, uint8_t* BAUD0, uint8_t* BAUD1, uint8_t* PRES )
{
	float value = (float)fosc / (float)(baudrate << 4);
	*BAUD0 = (((uint32_t)value) - 1) & 0XFF;
	*BAUD1 = ((((uint32_t)value) - 1) >> 8) & 0XFF;
	*PRES  = ((uint32_t)(value * 10)) % 10;
}

uint16_t WK_PortSendData( uint8_t port, const void* buf, uint16_t len )
{
	uint8_t  state = 0;
	uint16_t nsend = 0;
	state = WK_ReadSReg( port, WK2XXX_FSR );
	if (state & WK2XXX_TFULL)                    // 发送FIFO满
	{
		nsend = 0;
	} else
	{
		state = WK_ReadSReg( port, WK2XXX_TFCNT ); // 读取发送FIFO已用空间
		nsend = 256 - state;
		nsend = nsend >= len ? len : nsend;
		WK_WriteFIFO(port, buf, nsend);          // 将待发送的数据写入FIFO
	}
	return nsend;                                // 返回实际发送成功的数据量
}

uint16_t WK_PortRecvData( uint8_t port, void* buf, uint16_t len )
{
	uint8_t state = 0;
	uint8_t nread = 0;
	state = WK_ReadSReg( port, WK2XXX_FSR );
	if ( state & WK2XXX_RDAT )                      // 接收FIFO非空
	{
		nread = WK_ReadSReg( port, WK2XXX_RFCNT );  // 查询FIFO中的数据量 ?恰好256个？
		if ( nread == 0 )
		{
			nread= 256;
		}else{
			nread = len >= nread ? nread : len;			
		}
		WK_ReadFIFO( port, buf, nread );            // 读取FIFO中的数据
	}
	return nread;                                 // 返回实际读取到的数据量
}

void WK_PortInit( uint8_t port, uint32_t fosc, uint32_t baudrate )
{
	uint8_t BAUD0 = 0, BAUD1 = 0, PRES = 0, value = 0, ret = 0;

	/* 使能子串口时钟 */ 
	value = WK_ReadGReg( WK2XXX_GENA );
	value |= (1 << (port - 1));
	WK_WriteGReg( WK2XXX_GENA, value );
	ret = WK_ReadGReg( WK2XXX_GENA );

	/* 软件复位子串口 */ 
	value = WK_ReadGReg( WK2XXX_GRST );
	value |= (1 << (port - 1));
	WK_WriteGReg( WK2XXX_GRST, value );
	ret = WK_ReadGReg( WK2XXX_GRST );

	/*  使能子串口总中断 */ 
	value = WK_ReadGReg( WK2XXX_GIER );
	value |= (1 << (port - 1));
	WK_WriteGReg( WK2XXX_GIER, value );
	ret = WK_ReadGReg( WK2XXX_GIER );

	/* 使能子串口FIFO相关中断 */ 
	value = WK_ReadSReg( port, WK2XXX_SIER );
	value |= WK2XXX_RFTRIG_IEN;                  // 接收FIFO触点中断
//	value |= WK2XXX_TFTRIG_IEN;                  // 发送FIFO触点中断
//	value |= WK2XXX_RXOUT_IEN;                   // 接收FIFO超时中断
	WK_WriteSReg( port, WK2XXX_SIER, value );
	ret = WK_ReadSReg( port, WK2XXX_SIER );

	/* 设置FCR寄存器 */ 
	value = 0;
	value |= (1 << 0);  // 复位接收FIFO
	value |= (1 << 1);  // 复位发送FIFO
	value |= (1 << 2);  // 使能接收FIFO(这一步必须)
	value |= (1 << 3);  // 使能发送FIFO(这一步必须)
	value |= (0 << 4);  // 设置接收FIFO触点固定为8字节
	value |= (0 << 6);  // 设置发送FIFO触点固定为8字节
	WK_WriteSReg( port, WK2XXX_FCR, value );
	ret = WK_ReadSReg( port, WK2XXX_FCR );

	/* 切换到 page1 设置中断触点和波特率 */ 
	WK_WriteSReg( port, WK2XXX_SPAGE, 1 );
	ret = WK_ReadSReg( port, WK2XXX_SPAGE );

	WK_WriteSReg( port, WK2XXX_RFTL, 10 );      // 设置接收触点为10个字节
	ret = WK_ReadSReg( port, WK2XXX_RFTL );

	WK_WriteSReg( port, WK2XXX_TFTL, 10 );      // 设置发送触点为10个字节
	ret = WK_ReadSReg( port, WK2XXX_TFTL );

	WK_PortCalcBaudrate( fosc, baudrate, &BAUD0, &BAUD1, &PRES );  // 计算波特率

	WK_WriteSReg( port, WK2XXX_BAUD1, BAUD1 );  // 设置BAUD1
	ret = WK_ReadSReg( port, WK2XXX_BAUD1 );

	WK_WriteSReg( port, WK2XXX_BAUD0, BAUD0 );  // 设置BAUD0
	ret = WK_ReadSReg( port, WK2XXX_BAUD0 );

	WK_WriteSReg( port, WK2XXX_PRES, PRES );    // 设置PRES
	ret = WK_ReadSReg( port, WK2XXX_PRES );

	/* 切换回page0 */ 
	WK_WriteSReg( port, WK2XXX_SPAGE, 0 );
	ret = WK_ReadSReg( port, WK2XXX_SPAGE );

	/* 使能子串口收发 */ 
	value = WK_ReadSReg( port, WK2XXX_SCR );
	value |= WK2XXX_TXEN;
	value |= WK2XXX_RXEN;
	WK_WriteSReg( port, WK2XXX_SCR, value );
	ret = WK_ReadSReg( port, WK2XXX_SCR );
}


// 如果irq引脚接入了单片机的外部中断引脚，将该函数放入外部中断处理函数内。
// 对于WK2124所开启的中断可以这么处理：
void WK_IRQHandler( void )
{
	int i = 0;
	uint8_t GIFR = 0, SIFR = 0;

	/* 读取子串口全局中断寄存器  , 返回子串口 
		GIFR : Global Interupt Flag Register,
	 */
	GIFR = WK_ReadGReg( WK2XXX_GIFR );

	// 查询4个子串口是否发生中断
	for (i = 0; i < 4; i++)
	{
		if ((GIFR >> i) & 0X01)
		{
			/* 子串口中断标志寄存器
				SIFR ： Sub Uart Interupt Flag Register
			*/
			SIFR = WK_ReadSReg((i + 1), WK2XXX_SIFR);

			// 有接收FIFO触点中断， 置位，接收非空
			if ( SIFR & WK2XXX_RFTRIG_INT )
			{
				/* 调用WK_PortRecvData接收数据, 映射到指定的buff ,  */ 
			}

			// 有接收FIFO超时中断， 接收超时
			if ( SIFR & WK2XXX_RXOVT_INT )
			{

			}

			// 有发送FIFO触点中断， 置位子串口标记有发送
			if ( SIFR & WK2XXX_TFTRIG_INT )
			{

			}

			// 有发送FIFO空中断，置位子串口标记
			if ( SIFR & WK2XXX_TFEMPTY_INT )
			{

			}

			/*  有接收FIFO数据错误中断， 置位子串口标记
				重新发送对应串口操作 ？  需要子串口类记录上次发生
				子串口，要能调用父串口操作发送FIFO
			*/
			if ( SIFR & WK2XXX_FERR_INT )
			{

			}
		}
	}
}

/*************************************************************************/
// 函数功能: 	此函数主要是通过读写wk2xxx的寄存器来判断主接口的通信时序是否有问题
// 参数： 		无
// 返回值：		rv表示返回值，0成功  
/*************************************************************************/
uint8_t Wk2xxx_Test(void)
{
	uint8_t rec_data,rv;
	//主接口为SPI	
	rec_data = WK_ReadSReg( WK2XXX_GPORT, WK2XXX_GENA );
	if ( rec_data == 0x30 )
		return rv;
	else
	{
		rv = 1;
		return rv;
	}
}


/* 初始化
int main()
{
	int nrecv = 0;
	uint8_t buffer[256];
	
	// 硬件复位一下
	WK_Rst();
	
	// 初始化四个端口
	WK_PortInit(1, 11059200, 9600);  // WK2124晶振我用的是11.0592MHz的，这个值根据实际进行修改
	WK_PortInit(2, 11059200, 9600);
	WK_PortInit(3, 11059200, 9600);
	WK_PortInit(4, 11059200, 9600);
	
	// 发送数据
	WK_PortSendData(1, "helloworld\r\n", 12);
	WK_PortSendData(2, "helloworld\r\n", 12);
	WK_PortSendData(3, "helloworld\r\n", 12);
	WK_PortSendData(4, "helloworld\r\n", 12);
	
	// 接收数据，轮询方式
	nrecv = WK_PortRecvData(1, buffer, sizeof(buffer));
	
	if(nrecv != 0)
	{
		// 处理数据
	}
}
*/



// /***************************************************************************/
// //本文件为WK2XXX系列串口扩展芯片的设备驱动程序,作为驱动参开demo。使用者可以根据自身的情况加以修改，完善。

// /***************************************************************************/
// #include "wk2xxx.h"
// // #include "spi.h"
// // #include "usart.h"
// // #include "delay.h"


// void WK2XXX_RST_Init(void)
// {
// 	GPIO_InitTypeDef  GPIO_InitStructure;
// 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	 //使能PA,PD端口时钟
// 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;				 //PA.3 端口配置
// 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
// 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 //IO口速度为50MHz
// 	GPIO_Init(GPIOA, &GPIO_InitStructure);					 //根据设定参数初始化GPIOA.3
// 	GPIO_SetBits(GPIOA,GPIO_Pin_3);						 //PA.3 输出高	
// }

// void WK2XXX_Reset_Init(void)
// {
// 	GPIO_SetBits(GPIOA,GPIO_Pin_3);//1
// 	GPIO_ResetBits(GPIOA,GPIO_Pin_3);//0
// 	delay_ms(10);
// 	GPIO_SetBits(GPIOA,GPIO_Pin_3);//1	
// 	delay_ms(100);
		
// }
// /*************************************************************************/
// //函数功能：初始化SPI片选信号CS,并把CS的默认状态设置为高电平
// //
// //
// /*************************************************************************/
// void SPI_CS_Init(void)
// {
//  GPIO_InitTypeDef  GPIO_InitStructure;
//  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	 //使能PA,PD端口时钟
//  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4|GPIO_Pin_3;	//PA.4 端口配置
//  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 //推挽输出
//  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 //IO口速度为50MHz
//  GPIO_Init(GPIOA, &GPIO_InitStructure);					 //根据设定参数初始化GPIOA.4
//  GPIO_SetBits(GPIOA,GPIO_Pin_4);						 //PA.4 输出高	
// }
// /*************************************************************************/
// //函数功能：初始化SPI总线，设置SPI总线为0模式
// /*************************************************************************/
// void SPI_BUS_Init(void)
// {

// 	SPI1_Init();		   //初始化SPI
// 	SPI1_SetSpeed(SPI_BaudRatePrescaler_8);	//设置为10M时钟,高速模式
// }
// /*************************************************************************/
// //函数功能：设置CS信号为高电平
// /*************************************************************************/
// void SPI_CS_H(void)
// {
// 	GPIO_SetBits(GPIOA,GPIO_Pin_4);
// }
// /*************************************************************************/
// //函数功能：设置CS信号为低电平
// /*************************************************************************/
// void SPI_CS_L(void)
// {
// 	GPIO_ResetBits(GPIOA,GPIO_Pin_4);
// }
// /*************************************************************************/
// //函数功能：初始化SPI接口
// /*************************************************************************/
// void WK2XXX_SPI_Init(void)
// {
// 	SPI_CS_Init();
// 	SPI_BUS_Init();
	
	
// }

// /*************************************************************************/
// //函数功能：写寄存器函数（前提是该寄存器可写，某些寄存器如果你写1，可能会自动置1，具体见数据手册)
// //参数：port:为子串口的数(C0C1)
// //      reg:为寄存器的地址(A3A2A1A0)
// //      dat:为写入寄存器的数据
// //注意：在子串口被打通的情况下，向FDAT写入的数据会通过TX引脚输出
// //*************************************************************************/
// void Wk2xxxWriteReg(unsigned char port,unsigned char reg,unsigned char dat)
// {	 
// 	 SPI_CS_L();//片选使能
// 	 SPI1_ReadWriteByte(((port-1)<<4)+reg); //写控制字节
// 	 SPI1_ReadWriteByte(dat); //写数据
// 	 SPI_CS_H();//片选无效

// }


// /*************************************************************************/
// //函数功能：读寄存器函数
// //参数：port:为子串口的数(C0C1)
// //      reg:为寄存器的地址(A3A2A1A0)
// //      rec_data:为读取到的寄存器值
// //注意：在子串口被打通的情况下，读FDAT，实际上就是读取uart的rx接收的数据
// /*************************************************************************/
// unsigned char Wk2xxxReadReg(unsigned char port,unsigned char reg)
// {	
// 	unsigned char rec_data; 
// 	SPI_CS_L();	//片选使能
// 	SPI1_ReadWriteByte(0x40+((port-1)<<4)+reg);//写控制字节，控制命令构成见数据手册
// 	rec_data=SPI1_ReadWriteByte(0);//接收返回的数据
// 	SPI_CS_H();	//片选无效	
// 	return rec_data;
// }
// /**************************** Wk2xxxWriteFifo*********************************************/
// //函数功能：该函数为写FIFO函数，通过该函数写入的数据会直接进入子串口的发送FIFO，然后通过TX引脚发送
// //参数：port：为子串口的端口号(C0\C1)
// //      *wbuf:写入数据部分
// //      len：  写入数据长度
// //
// /*************************************************************************/
// void Wk2xxxWriteFifo(unsigned char port,unsigned char *wbuf,unsigned int len)
// {	 unsigned char n;
// 	 SPI_CS_L(); // 片选有效
// 	 SPI1_ReadWriteByte(0x80+((port-1)<<4)); //写FIFO控制指令
// 	  for(n=0;n<len;n++)
// 	    {
// 	     SPI1_ReadWriteByte(*(wbuf+n));
// 		} 
// 	 SPI_CS_H();	//片选无效

// }

// /**************************** Wk2xxxReadFifo*********************************************/
// //函数功能：该函数为读FIFO函数，通过该函数可以一次读出多个接收FIFO中的数据，最多256个字节
// //参数：port：为子串口的端口号(C0\C1)
// //      *rbuf:写入数据部分
// //      len：  写入数据长度
// //
// /*************************************************************************/
// void Wk2xxxReadFifo(unsigned char port,unsigned char *rbuf,unsigned int len)
// {	 unsigned char n;
// 	 SPI_CS_L();//片选有效
// 	 SPI1_ReadWriteByte(0xc0+((port-1)<<4));	//写读fifo控制指令
// 	 for(n=0;n<len;n++)
// 	   {
// 		*(rbuf+n)=SPI1_ReadWriteByte(0); 
// 	   }
// 	 SPI_CS_H();//片选无效										
// 	 //return 0;
// }

// /*************************************************************************/
// //函数功能:此函数主要是通过读写wk2xxx的寄存器来判断主接口的通信时序是否有问题
// //参数：无
// //返回值：rv表示返回值，0成功  
// /*************************************************************************/
//  unsigned char Wk2xxxTest(void)
//  {
// 	unsigned char rec_data,rv;
// //主接口为SPI	
// 	rec_data=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GENA);
// 	if(rec_data==0x30)
// 		return rv;
// 	else
// 		{
// 			rv=1;
// 			return rv;
// 		}

//  }
// /******************************Wk2xxxInit*******************************************/
// //函数功能：本函数主要会初始化一些芯片基本寄存器；
// /*********************************************************************************/
// void Wk2xxxInit(unsigned char port)
// {
//     unsigned char gena,grst,gier,sier,scr;
// 	//使能子串口时钟
//     gena=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GENA); 
// 	switch (port)
//     {
//           case 1://使能子串口1的时钟
//               gena|=WK2XXX_UT1EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 		  case 2://使能子串口2的时钟
//               gena|=WK2XXX_UT2EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 		   case 3://使能子串口3的时钟
//               gena|=WK2XXX_UT3EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 		   case 4://使能子串口4的时钟
//               gena|=WK2XXX_UT4EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 	 }	
// 	//软件复位子串口
// 	grst=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GRST); 
// 	switch (port)
//     {
//           case 1://软件复位子串口1
//               grst|=WK2XXX_UT1RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 		  case 2://软件复位子串口2
//               grst|=WK2XXX_UT2RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 		   case 3://软件复位子串口3
//               grst|=WK2XXX_UT3RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 		   case 4://软件复位子串口4
//              grst|=WK2XXX_UT4RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 	 }	
//   //使能子串口中断，包括子串口总中断和子串口内部的接收中断，和设置中断触点
// 	gier=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GIER); 
// 	switch (port)
//     {
//           case 1://软件复位子串口1
//               gier|=WK2XXX_UT1RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
//               break;
// 		  case 2://软件复位子串口2
//               gier|=WK2XXX_UT2RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
//               break;
// 		   case 3://软件复位子串口3
//               gier|=WK2XXX_UT3RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
//               break;
// 		   case 4://软件复位子串口4
//               gier|=WK2XXX_UT4RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GIER,gier);
//               break;
// 	 }	 
// 	 //使能子串口接收触点中断和超时中断
// 	 sier=Wk2xxxReadReg(port,WK2XXX_SIER); 
// 	 sier |= WK2XXX_RFTRIG_IEN|WK2XXX_RXOVT_IEN;
// 	 Wk2xxxWriteReg(port,WK2XXX_SIER,sier);
// 	 // 初始化FIFO和设置固定中断触点
// 	 Wk2xxxWriteReg(port,WK2XXX_FCR,0XFF);
// 	 //设置任意中断触点，如果下面的设置有效，那么上面FCR寄存器中断的固定中断触点将失效
// 	 Wk2xxxWriteReg(port,WK2XXX_SPAGE,1);//切换到page1
// 	 Wk2xxxWriteReg(port,WK2XXX_RFTL,0X40);//设置接收触点为64个字节
// 	 Wk2xxxWriteReg(port,WK2XXX_TFTL,0X10);//设置发送触点为16个字节
// 	 Wk2xxxWriteReg(port,WK2XXX_SPAGE,0);//切换到page0 
// 	 //使能子串口的发送和接收使能
// 	 scr=Wk2xxxReadReg(port,WK2XXX_SCR); 
// 	 scr|=WK2XXX_TXEN|WK2XXX_RXEN;
// 	 Wk2xxxWriteReg(port,WK2XXX_SCR,scr);
// }

// /******************************Wk2xxxClose*******************************************/
// //函数功能：本函数会关闭当前子串口，和复位初始值；
// /*********************************************************************************/

// void Wk2xxxClose(unsigned char port)
// {
//     unsigned char gena,grst;
// 	//复位子串口
// 	grst=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GRST); 
// 	switch (port)
//     {
//           case 1://软件复位子串口1
//               grst|=WK2XXX_UT1RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 		  case 2://软件复位子串口2
//               grst|=WK2XXX_UT2RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 		   case 3://软件复位子串口3
//               grst|=WK2XXX_UT3RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 		   case 4://软件复位子串口4
//               grst|=WK2XXX_UT4RST;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GRST,grst);
//               break;
// 	 }	
// 	//关闭子串口时钟
//     gena=Wk2xxxReadReg(WK2XXX_GPORT,WK2XXX_GENA); 
// 	switch (port)
//     {
//           case 1://使能子串口1的时钟
//               gena&=~WK2XXX_UT1EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 		  case 2://使能子串口2的时钟
//               gena&=~WK2XXX_UT2EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 		   case 3://使能子串口3的时钟
//               gena&=~WK2XXX_UT3EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 		   case 4://使能子串口4的时钟
//               gena&=~WK2XXX_UT4EN;
// 		      Wk2xxxWriteReg(WK2XXX_GPORT,WK2XXX_GENA,gena);
//               break;
// 	 }	
// }






// /**************************Wk2xxxSetBaud*******************************************************/
// //函数功能：设置子串口波特率函数、此函数中波特率的匹配值是根据11.0592Mhz下的外部晶振计算的
// // port:子串口号
// // baud:波特率大小.波特率表示方式，
// //
// /**************************Wk2xxxSetBaud*******************************************************/
// void Wk2xxxSetBaud(unsigned char port,int baud)
// {  
// 	unsigned char baud1,baud0,pres,scr;
// 	//如下波特率相应的寄存器值，是在外部时钟为11.0592的情况下计算所得，如果使用其他晶振，需要重新计算
// 	switch (baud) 
// 	{
//       case 1:
// 			baud1=0x4;
// 			baud0=0x7f;
// 			pres=0;
//       break;
//       case 2:
// 			baud1=0x2;
// 			baud0=0x3F;
// 			pres=0;
// 			break;
//       case 3:
// 			baud1=0x1;
// 			baud0=0x1f;
// 			pres=0;
// 			break;
//       case 4:
// 			baud1=0x00;
// 			baud0=0x8f;
// 			pres=0;
// 			break;
//       case 5:
// 			baud1=0x00;
// 			baud0=0x47;
// 			pres=0;
// 			break;
//       case 6:
// 			baud1=0x00;
// 			baud0=0x23;
// 			pres=0;
// 			break;
//       case 7:
// 			baud1=0x00;
// 			baud0=0x11;
// 			pres=0;
// 			break;
			
//       case 8:
// 			baud1=0x00;
// 			baud0=0x08;
// 			pres=0;
// 			break; 
       
//       case 9:
// 			baud1=0x01;
// 			baud0=0x7f;
// 			pres=0;
// 			break;
//       case 10:
// 			baud1=0x00;
// 			baud0=0xbf;
// 			pres=0;
// 			break;
//       case 11:
// 			baud1=0x00;
// 			baud0=0x5f;
// 			pres=0;
// 			break;
//       case 12:
// 			baud1=0x00;
// 			baud0=0x2f;
// 			pres=0;
// 			break;
//       case 13:
// 			baud1=0x00;
// 			baud0=0x17;
// 			pres=0;
// 			break;
//       case 14:
// 			baud1=0x00;
// 			baud0=0x0b;
// 			pres=0;
//       break;
//       case 15:
// 			baud1=0x00;
// 			baud0=0x05;
// 			pres=0;
// 			break;
//       case 16:
// 			baud1=0x00;
// 			baud0=0x02;
// 			pres=0;
// 			break;
//       default:
// 			baud1=0x00;
// 			baud0=0x00;
// 			pres=0;
//     }
// 	//关掉子串口收发使能
// 	scr=Wk2xxxReadReg(port,WK2XXX_SCR); 
// 	Wk2xxxWriteReg(port,WK2XXX_SCR,0);
// 	//设置波特率相关寄存器
// 	Wk2xxxWriteReg(port,WK2XXX_SPAGE,1);//切换到page1
// 	Wk2xxxWriteReg(port,WK2XXX_BAUD1,baud1);
// 	Wk2xxxWriteReg(port,WK2XXX_BAUD0,baud0);
// 	Wk2xxxWriteReg(port,WK2XXX_PRES,pres);
// 	Wk2xxxWriteReg(port,WK2XXX_SPAGE,0);//切换到page0 
// 	//使能子串口收发使能
// 	Wk2xxxWriteReg(port,WK2XXX_SCR,scr);
	
	
// }
// /*****************************Wk2xxxSendBuf****************************************/
// //本函数为子串口发送数据的函数，发送数据到子串口的FIFO.然后通过再发送
// //参数说明：port：子串口端口号
// //          *sendbuf:需要发送的数据buf
// //          len：需要发送数据的长度
// // 函数返回值：实际成功发送的数据
// //说明：调用此函数只是把数据写入子串口的发送FIFO，然后再发送。1、首先确认子串口的发送FIFO有多少数据，根据具体情况、
// //确定写入FIFO数据的个数，
// /*********************************************************************/
// unsigned int Wk2xxxSendBuf(unsigned char port,unsigned char *sendbuf,unsigned int len)
// {
// 	 unsigned int ret,tfcnt,sendlen;
// 	 unsigned char  fsr;
	  
// 	 fsr=Wk2xxxReadReg(port,WK2XXX_FSR);
// 	 if(~fsr&WK2XXX_TFULL )//子串口发送FIFO未满
// 	 {

// 	     tfcnt=Wk2xxxReadReg(port,WK2XXX_TFCNT);//读子串口发送fifo中数据个数
// 		 sendlen=256-tfcnt;//FIFO能写入的最多字节数
		 
// 		 if(sendlen<len)
// 		 {
// 			ret=sendlen; 
// 			Wk2xxxWriteFifo(port,sendbuf,sendlen);
// 		 }
// 		 else
// 		 {
// 			 Wk2xxxWriteFifo(port,sendbuf,len);
// 			 ret=len;
// 		 }
// 	  }
	 
// 	 return ret;
// }

// /*****************************Wk2xxxGetBuf****************************************/
// //本函数为子串口接收数据函数
// //参数说明：port：子串口端口号
// //          *getbuf:接收到的数据buf
// // 函数返回值：实际接收到的数据个数
// /*********************************************************************/
// unsigned int Wk2xxxGetBuf(unsigned char port,unsigned char *getbuf)
// {
// 	unsigned int ret=0,rfcnt;
// 	unsigned char fsr;
// 	fsr=Wk2xxxReadReg(port,WK2XXX_FSR);
// 	if(fsr&WK2XXX_RDAT )//子串口接收FIFO未空
// 	  {
// 	     rfcnt=Wk2xxxReadReg(port,WK2XXX_RFCNT);//读子串口发送fifo中数据个数
// 		 if(rfcnt==0)//当RFCNT寄存器为0的时候，有两种情况，可能是256或者是0，这个时候通过FSR来判断，如果FSR显示接收FIFO不为空，就为256个字节
// 		 {rfcnt=256;}
// 		 Wk2xxxReadFifo(port,getbuf,rfcnt);
// 		 ret=rfcnt;
// 	   }
// 	 return ret;	
// }

