#include "usart.h"

//加入以下代码,支持printf函数,而不需要选择use MicroLIB	  
#if 0
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE 
{ 
	int handle; 
	/* Whatever you require here. If the only file you are using is */ 
	/* standard output using printf() for debugging, no file handling */ 
	/* is required. */ 
}; 
/* FILE is typedef’ d in stdio.h. */ 
FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
void _sys_exit(int x) 
{
	x = x; 
} 
//重定义fputc函数 
int fputc(int ch, FILE *f)
{  
	while(!((USART2->ISR)&(1<<7))){}
  USART1->TDR=ch;
  return (ch);
}
#endif 

uint8_t rsTxBuf[USART1_TX_BUFSIZE];
uint8_t rsRxBuf[USART1_RX_BUFSIZE];

u8 Usart1_rxFLag=0;
u16 cnter;
u16 Usart1rxcounter=0;
u16 Usart1txcounter=0;

extern u8 CT_Single;
extern u8 CT_Tens;
extern u8 CT_Huns;

extern u8 PT_Single;
extern u8 PT_Tens;
extern u8 PT_Huns;

//F030RxBUFF_T g_f030RxBuff;

SettingParams SettingPara;

volatile DataStructure DataStruc;

u8 sendData[50]={0};
unsigned char const TabH[] = {  //CRC??????
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
    0x00, 0xC1, 0x81, 0x40
} ;
unsigned char const TabL[] = {  //CRC??????
    0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7,
    0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E,
    0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9,
    0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC,
    0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
    0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32,
    0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D,
    0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38,
    0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF,
    0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
    0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1,
    0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4,
    0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB,
    0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA,
    0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
    0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0,
    0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97,
    0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E,
    0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89,
    0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
    0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83,
    0x41, 0x81, 0x80, 0x40
} ;


//void DMA_Config(void)
//{

//	DMA_InitTypeDef DMA_InitStructure; 
//	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); 
//	DMA_DeInit(DMA1_Channel3);
//	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&USART1->RDR); 	
//	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)rsRxBuf;
//  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
//	DMA_InitStructure.DMA_BufferSize = USART1_RX_BUFSIZE;
//	DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; 
//	DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; 
//	DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
//	DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
//	DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
//	DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh; 	
//	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; 
//	DMA_Init(DMA1_Channel3,&DMA_InitStructure); 
//	DMA_Cmd(DMA1_Channel3,ENABLE);
//}




/* USART初始化 */
void USART1_Init(void)
{
//	GPIO_InitTypeDef GPIO_InitStructure;
//	USART_InitTypeDef USART_InitStructure;
//	NVIC_InitTypeDef NVIC_InitStruct;
//	
//	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);  //使能GPIOA的时钟
//	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);//使能USART的时钟

//		/* USART1的端口配置 */
//	GPIO_PinAFConfig(GPIOA, GPIO_Pin_2, GPIO_AF_1);//配置PA9成第二功能引脚	TX
//	GPIO_PinAFConfig(GPIOA, GPIO_Pin_3, GPIO_AF_1);//配置PA10成第二功能引脚  RX
//	
//	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3;
//	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
//	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_1;
//	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
//	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
//	GPIO_Init(GPIOA, &GPIO_InitStructure);

////	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;	
////	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
////	GPIO_Init(GPIOA, &GPIO_InitStructure);
//	
//		

//	/* USART1的基本配置 */
//	USART_InitStructure.USART_BaudRate = 9600;              //波特率
//	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
//	USART_InitStructure.USART_StopBits = USART_StopBits_1;
//	USART_InitStructure.USART_Parity = USART_Parity_No;
//	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
//	USART_Init(USART1, &USART_InitStructure);
//	
//	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
//	USART_Cmd(USART1, ENABLE);
//	
//	
//	/* USART1的NVIC中断配置 */

//	NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
//	NVIC_InitStruct.NVIC_IRQChannelPriority = 0x01;
//	NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
//	NVIC_Init(&NVIC_InitStruct);
////	USART_ClearFlag(USART1,USART_FLAG_TC);
////	USART_ITConfig(USART1,USART_IT_RXNE, ENABLE);
//	USART_InitTypeDef USART_InitStructure;
//	NVIC_InitTypeDef NVIC_InitStructure;
//	GPIO_InitTypeDef GPIO_InitStructure; 
//	
//	
//	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
//	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
//	
//	GPIO_PinAFConfig(GPIOA, GPIO_Pin_2, GPIO_AF_1);
//	GPIO_PinAFConfig(GPIOA, GPIO_Pin_3, GPIO_AF_1);

//	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
//	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
//	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
//	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
//	GPIO_Init(GPIOA, &GPIO_InitStructure);
//	
//	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
//	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
//	GPIO_Init(GPIOA, &GPIO_InitStructure);
//	

//	USART_InitStructure.USART_BaudRate = 9600;
//	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
//	USART_InitStructure.USART_StopBits = USART_StopBits_1;
//	USART_InitStructure.USART_Parity = USART_Parity_No;
//	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
//	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
//	USART_Init(USART1, &USART_InitStructure);
//	
//	/* Enable USART */
//	USART_Cmd(USART1, ENABLE);
//	/* Enable the USARTx Interrupt */
//	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
//	NVIC_InitStructure.NVIC_IRQChannel=1;
//	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
//	NVIC_Init(&NVIC_InitStructure);	
//	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
//	USART_ITConfig(USART1,USART_IT_IDLE,ENABLE);
//	
//	USART_ClearFlag(USART1, USART_FLAG_TC);

	GPIO_InitTypeDef  GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;                
	RCC_AHBPeriphClockCmd( RCC_AHBPeriph_GPIOA, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE );                
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource2,GPIO_AF_1);
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource3,GPIO_AF_1);        
	/*
	*  USART1_TX -> PA2 , USART1_RX -> PA3
	*/                                
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;                 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; 
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOA, &GPIO_InitStructure);     

	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;                 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; 
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 
	GPIO_Init(GPIOA, &GPIO_InitStructure);
  //DMA_Config();
	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_Init(USART1, &USART_InitStructure);

	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);
	USART_ITConfig(USART1,USART_IT_IDLE,ENABLE);
	
	USART_ClearFlag(USART1, USART_FLAG_TC);
	USART_ClearFlag(USART1, USART_IT_RXNE);
	
	USART1->ICR |= 1<<4;
//	USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE); 
	/* Enable USART */
	USART_Cmd(USART1, ENABLE);

	/* Enable the USARTx Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	
}

//=============================================================================
//文件名称：
//功能概要：USART1中断函数
//参数说明：无
//函数返回：无
//=============================================================================
void USART1_IRQHandler()  
{
	u8 Clear;
																							 //
    if(USART_GetFlagStatus(USART1,USART_FLAG_ORE) != RESET)                                             	 //
    {                                                                                                    //
			USART_ReceiveData(USART1);
			USART_ClearFlag(USART1,USART_FLAG_ORE);                                                                    	 //
    }
	if(USART_GetITStatus(USART1,USART_IT_RXNE) != RESET)
	{
		rsRxBuf[cnter++] = USART1->RDR;
		if(cnter>USART1_RX_BUFSIZE)
			cnter=0;
	}
	else if(USART_GetITStatus(USART1,USART_IT_IDLE) != RESET)
	{
		Clear = USART1->RDR;
		Clear = USART1->ISR;
		Usart1_rxFLag =1;
		USART1->ICR |= 1<<4;
	}	
}


void USART1TxData(void *data, int len)
{
	u8* p;
	p = (u8*)data;

	while(len--) {
		USART_SendData(USART1,*p++);
		while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
	}  
	
}


void USART1SendData(void)
{
	u16 crccode,buflen;
	u8 len=0;
//	Usart1txcounter = 0;
	len=sizeof(SettingPara)+2;
	SettingPara.CTscale=CT_Huns*100+CT_Tens*10+CT_Single;
	SettingPara.PTscale=PT_Huns*100+PT_Tens*10+PT_Single;
	
	sendData[0]=0xfa;
	sendData[1]=0xfb;
	sendData[2]=0xfa;
	sendData[3]=0xfb;
	sendData[4]=0x06;
	sendData[5]=len;
	memcpy(&sendData[6],&SettingPara,sizeof(SettingPara));
	crccode = GetCRC16(sendData, len+5);
	sendData[len+4]=(u8)crccode&0x00ff;
	sendData[len+5]=(u8)((crccode&0xff00)>>8);
	buflen=sizeof(sendData);
	USART1TxData(sendData,buflen);
}


unsigned short GetCRC16(unsigned char *pbuf,  unsigned short len)
{
    unsigned int index;
    unsigned char crch = 0xFF;  //?CRC??
    unsigned char crcl = 0xFF;  //?CRC??
		while (len--)  //???????CRC
    {
			index = crch ^ *pbuf++;
			crch = crcl ^ TabH[index];
			crcl = TabL[index];
    }
    return ((crch<<8) | crcl);
}

void ExistRXInformation(void)
{
	u8 crcH=0;
	u8 crcL=0;
	u16 crcCode=0;
	u8 tmp[5] = {0xfa,0xfb,0xfa,0xfb,0x04};

	if(Usart1_rxFLag == 1)
	{	
	  if(rsRxBuf[0]==0xfa && rsRxBuf[1]==0xfb && rsRxBuf[2]==0xfa && rsRxBuf[3]==0xfb && rsRxBuf[4]==0x04)//&&rsRxBuf[5]==sizeof(DataStruc)+1)//功能码	
		{
			crcCode = GetCRC16(&rsRxBuf[6],rsRxBuf[5]-2);
			crcL = (u8)crcCode&0x00ff;
			crcH = (u8)((crcCode&0xff00)>>8);

			if((rsRxBuf[cnter-1] == crcH) && (rsRxBuf[cnter-2] == crcL))
			{
				memcpy(&DataStruc, &rsRxBuf[6],sizeof(DataStruc));		
			}
		}
		
		Usart1_rxFLag = 0;
		cnter = 0;
		memset(rsRxBuf,0,USART1_RX_BUFSIZE);
	}
}

void requestData(void)
{

	Usart1txcounter=0;
	
	rsTxBuf[Usart1txcounter++]=0xfa;
	rsTxBuf[Usart1txcounter++]=0xfb;
	rsTxBuf[Usart1txcounter++]=0xfa;
	rsTxBuf[Usart1txcounter++]=0xfb;
	rsTxBuf[Usart1txcounter++]=0x04;
	rsTxBuf[Usart1txcounter++]=0x03;
	rsTxBuf[Usart1txcounter++]=0x01;
	rsTxBuf[Usart1txcounter++]=0x7e;
	rsTxBuf[Usart1txcounter++]=0x80;

	USART1TxData(rsTxBuf,Usart1txcounter);	
	memset(rsTxBuf,0,sizeof(rsTxBuf));

}



