#include "Usart.h"
#include <string.h>
#include <stdio.h>
#include "modbus.h"

//Êý¾Ý·¢ËͶÓÁбäÁ¿
EUART_Frame m_EUART_TxFrames[EUART_TX_FRM_SIZE];	//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐ	
volatile int8_t m_EUART_TxFrm_Tail = 0;					//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐβָÕë
volatile int8_t m_EUART_TxFrm_Head = 0;					//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐÍ·Ö¸Õë
volatile int8_t m_EUART_TxFrm_FreeFrmLen = 0;			//Êý¾Ý·¢ËÍÖ¡¶ÓÁÐÊ£ÓàÖ¡Êý
//DMAÊý¾Ý½ÓÊÕ»º´æ
uint8_t m_EUART_DMA_RXBuf[EUART_RX_BUF_SIZE];			//DMAÊý¾Ý½ÓÊÕ»º´æ
volatile int32_t m_EUART_DMA_RXPtr = 0;					//µ±Ç°Êý¾ÝµØÖ·
int16_t DMA_rxtemp = 0,DMA_rxtemp2 = 0;															//µ±Ç°Êý¾ÝµØÖ·»º´æ
u16 datadelaycount = 0;													//Ê£Óà1λÊý¾ÝÑÓʱµÈ´ý´¦Àí
//±êÖ¾±äÁ¿
volatile uint8_t m_bEUARTPushingFrms = 0;				//ÕýÔÚÍù·¢ËͶÓÁдæÊý¾Ý
volatile uint8_t m_bEUARTCheckingSend = 0;				//ÕýÔÚÈ·ÈÏÊý¾Ý·¢ËÍ
volatile uint8_t m_bEUARTCheckingRec = 0;				//ÕýÔÚÈ·ÈϽÓÊÕÊý¾Ý
volatile uint8_t m_bEUARTTxEn = 0;						//ʹÄÜ·¢ËÍ

void (*Usart1ParseDataCallback)(uint8_t);
void Usart1InitVariables(void)
{	
	m_EUART_TxFrm_FreeFrmLen = EUART_TX_FRM_SIZE-1;
}

//UART DMAµÄÅäÖÃ
void UART_DMAConfiguration(void)
{
	DMA_InitTypeDef DMA_InitStructure;

	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	
	//UARTµÄDMAÊý¾Ý½ÓÊÕ³õʼ»¯
	DMA_DeInit(EUART_RX_DMA_CH);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)( &(EXT_UART->DR));			//ÍâÉèÊý¾Ý¼Ä´æÆ÷
	DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)m_EUART_DMA_RXBuf;				//Êý¾ÝBuf
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;							//ÍâÉè×÷Ô´Í·
	DMA_InitStructure.DMA_BufferSize = EUART_RX_BUF_SIZE;						//Buf´óС
	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_Circular;								//Ñ­»·Ä£Ê½
	DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;						//ÓÅÏȼ¶
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;								//·ÇÄÚ´æµ½ÄÚ´æ
	DMA_Init(EUART_RX_DMA_CH, &DMA_InitStructure);
	USART_DMACmd(EXT_UART, USART_DMAReq_Rx, ENABLE);							
	DMA_Cmd(EUART_RX_DMA_CH, ENABLE);			
	
#ifdef EXUART_USE_TXDMA
	//UARTµÄDMAÊý¾Ý·¢Ëͳõʼ»¯
	DMA_DeInit(EUART_TX_DMA_CH);
	DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&(EXT_UART->DR));			//ÍâÉèÊý¾Ý¼Ä´æÆ÷
	DMA_InitStructure.DMA_MemoryBaseAddr = 0;									//Êý¾ÝBuf
	DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;							//ÍâÉè×÷Ä¿±ê
	DMA_InitStructure.DMA_BufferSize = 0;										//Buf´óС
	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_High;							//ÓÅÏȼ¶
	DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;								//·ÇÄÚ´æµ½ÄÚ´æ
	DMA_Init(EUART_TX_DMA_CH, &DMA_InitStructure);

//	DMA_ITConfig(EUART_TX_DMA_CH, DMA_IT_TC, ENABLE);							//DMA´«ÊäÍê³ÉÖжÏ
	USART_DMACmd(EXT_UART,USART_DMAReq_Tx,ENABLE);								//ÍâÉèʹÄÜDMA  // */
#endif						
}

void Uart1_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	USART_ClockInitTypeDef USART_ClockInitStructure;
	
	/* Enable GPIO clock */
    RCC_APB2PeriphClockCmd(EU_RCC_GPIO | RCC_APB2Periph_AFIO, ENABLE);
	/* Enable USART clock */
    RCC_APB2PeriphClockCmd(EXT_UART_RCC, ENABLE);
	
	Usart1InitVariables();
	
	//³õʼ»¯¹Ü½Å
	GPIO_InitStructure.GPIO_Pin = EU_RX_PIN;
	GPIO_InitStructure.GPIO_Mode =GPIO_Mode_IN_FLOATING;							//RxÉÏÀ­ÊäÈë
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(EU_RX_GPIO, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = EU_TX_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;							//TxÍÆÍ츴ÓÃÊä³ö GPIO_Mode_AF_PP
	GPIO_Init(EU_TX_GPIO, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = EU_485_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;							//TxÍÆÍ츴ÓÃÊä³ö GPIO_Mode_AF_PP
	GPIO_Init(EU_485_GPIO, &GPIO_InitStructure);
	OUT485_DISABLE;
#ifdef UART_GPIO_REMAP_ENABLE
	GPIO_PinRemapConfig(UART_GPIO_REMAP, ENABLE);
#endif
	
	USART_DeInit(EXT_UART);
	USART_InitStructure.USART_BaudRate = EXUART_BAUD_RADE;
	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_ClockInitStructure.USART_Clock = USART_Clock_Disable;
	USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
	USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
	USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
	
	USART_ClockInit(EXT_UART, &USART_ClockInitStructure);
	USART_Init(EXT_UART, &USART_InitStructure);
//	USART_ITConfig(EXT_UART, USART_IT_RXNE, ENABLE);//??????,????? ??????????
	// Enable the USARTx 
	USART_Cmd(EXT_UART, ENABLE); 
	//DMAÅäÖã¨Ðë·Åµ½UART³õʼ»¯Ö®ºó£©
	UART_DMAConfiguration();
	
}
extern u8 cmd_mode;
u8 overrun_flag=0;
u16 t1,t2,t3,t4;
void UART_CheckReceive(void)
{
	int32_t DMACnt = 0;
	int32_t MaxDataLen = EUART_RX_BUF_SIZE;	
	u8 rxbuf_len = 0;
	u8 buftemp1 = 0;
	u8 buftemp2 = 0;
	u8 i = 0;
	//Èç¹ûÕýÔÚÍù·¢ËͶÓÁÐÖÐÌí¼ÓÊý¾Ý£¬Í˳ö
	if(m_bEUARTPushingFrms)
		return;
	//ÅжÏÊÇ·ñÕýÔÚCheck
	if(m_bEUARTCheckingRec)
		return;
	m_bEUARTCheckingRec = 1;
	if(EUART_RX_DMA_CH->CNDTR == 0)
	{
		m_bEUARTCheckingRec = 0;
		return;
	}
	
	DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);//DMACntÊÇDMAͨµÀ½ÓÊÕµ½Êý¾Ý×ܳ¤¶È,CNDTRÊÇdmaÊ£ÓàδʹÓÃÊýÁ¿
	
	if(DMACnt!=m_EUART_DMA_RXPtr)
	{
		//DMAÓÐδ´¦ÀíÊý¾Ý
		DMA_rxtemp=m_EUART_DMA_RXPtr+1;
		delay_us(10);
		overrun_flag=0;
		if( DMA_rxtemp >= EUART_RX_BUF_SIZE )
		{
			DMA_rxtemp = 0;
		}
		DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);//DMACntÊÇDMAͨµÀ½ÓÊÕµ½Êý¾Ý×ܳ¤¶È,CNDTRÊÇdmaÊ£ÓàδʹÓÃÊýÁ¿
		if(DMACnt!=DMA_rxtemp&&(cmd_mode==0))
		{
			//DMAÓг¬¹ý2λÊý¾Ýδ´¦Àí
			DMA_rxtemp = 0;//Çå¿ÕÊý×éÖ¸Õë
			datadelaycount = 0;//µÈ´ý´ÎÊýÇåÁã
			buftemp1 = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr];
			buftemp2 = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr+1];
			if((buftemp1==0x55)&&(buftemp2==0xAA))
			{
				//˽ÓÐЭÒé
				cmd_mode = 1;
			}
			else if(buftemp1==RS485_Addr)
			{
				if((buftemp2==03)||(buftemp2==06)||(buftemp2==16))//¹¦ÄÜÂëÕýÈ·
				{
					//modubsЭÒé
					t1++;
					cmd_mode=2;
					DMA_rxtemp2=m_EUART_DMA_RXPtr+7;
					if( DMA_rxtemp2 >= EUART_RX_BUF_SIZE-1 )
						{
							DMA_rxtemp2 -= EUART_RX_BUF_SIZE;
							overrun_flag=1;
						}
				}
				else
				{
					m_EUART_DMA_RXPtr+=2;
					if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
					{
						m_EUART_DMA_RXPtr = 0;
					}					
				}
			}
			else
			{
				//ÎÞЧÂ룬¸ÉÈÅÂë
				if(cmd_mode==0)
				{
						m_EUART_DMA_RXPtr+=2;
						if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
						{
							m_EUART_DMA_RXPtr = 0;
						}
				 }
			 }			
		}
		else
		{
			//Ö»ÓÐ1λÊý¾Ýδ´¦Àí
				if(++datadelaycount > WAITDELAYCOUNT)
				{	//³¬³öµÈ´ý´ÎÊý
					datadelaycount = 0;
					cmd_mode=0;
					m_EUART_DMA_RXPtr++;
					if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
					{
						m_EUART_DMA_RXPtr = 0;
					}					
				}
		}
		if(cmd_mode==1)
		{
			//˽ÓÐЭÒé
			while( m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
			{	
				Usart1ParseDataCallback(m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]);
				m_EUART_DMA_RXPtr++;
				if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
				{
					m_EUART_DMA_RXPtr = 0;
				}
				DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
				MaxDataLen--;	
			}
		}		
		else if(cmd_mode==2)
		{
			//modbusЭÒé
			delay_ms(10);//µÈ´ýÊý¾Ý½ÓÊÕÍê³É
			DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);	
		if((overrun_flag==0&&DMACnt>DMA_rxtemp2)||(overrun_flag==1&&DMACnt<DMA_rxtemp&&DMACnt>DMA_rxtemp2))			
		{	while(m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
			{
				RS485_RX_BUFF[i] = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr];
				m_EUART_DMA_RXPtr++;
				if(++i >= EUART_RX_BUF_SIZE)i = 0;
				if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
				{
					m_EUART_DMA_RXPtr = 0;
				}
				DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
				MaxDataLen--;	
			}
//			m_EUART_DMA_RXPtr++;//Êý¾ÝÖ¸ÏòÏÂһλ
//			if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
//			{
//				m_EUART_DMA_RXPtr = 0;
//			}
			t2++;
				RS485_Service();	
		}			
			}				
		}

	m_bEUARTCheckingRec = 0;
}



#ifndef EXUART_USE_TXDMA							
//²éѯ·½Ê½·¢ËÍÊý¾Ý
void UART_CheckSend(void)
{
	static int32_t s_count = 0;
//	uint32_t temp32 = 0;

	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	m_bEUARTCheckingSend = 1;

	//Åж϶ÓÁÐÊÇ·ñΪ¿ÕÒÔ¼°DMAÊÇ·ñ¿ÕÏÐ
	if ((EXT_UART->SR & USART_FLAG_TXE) == (uint16_t)RESET)	//Éϴη¢ËÍδÍê³É
	{
		m_bEUARTCheckingSend = 0;
		return;
	}
	
	if(m_EUART_TxFrm_Head == m_EUART_TxFrm_Tail)					//¶ÓÁÐΪ¿Õ
	{
		if((EXT_UART->SR & USART_FLAG_TC) != (uint16_t)RESET)	 	//·¢ËÍÍê±Ï
		{
			if(m_bEUARTTxEn)
			{
				OUT485_DISABLE;
				m_bEUARTTxEn = 0;
//				temp32 = GPIOC->CRH;			//C10Ðü¿ÕÊäÈë
//				temp32 &= ~(0x00000000F<<8);		
//				temp32 |= (0x000000004<<8);
//				GPIOC->CRH = temp32;// */
			}
		}
		m_bEUARTCheckingSend = 0;
		return;
	}
	
	if(!m_bEUARTTxEn)
	{
		m_bEUARTTxEn = 1;
		OUT485_ENABLE;
		delay_us(10);
//		temp32 = GPIOC->CRH;			//C10¸´ÓÃÍÆÍìÊä³ö
//		temp32 &= ~(0x00000000F<<8);
//		temp32 |= (0x000000009<<8);
//		GPIOC->CRH = temp32;// */
	}
	
	//·¢ËÍÒ»¸ö×Ö½ÚÊý¾Ý
	EXT_UART->DR = m_EUART_TxFrames[m_EUART_TxFrm_Tail].buf[s_count];		
	s_count++;
	if(s_count >= m_EUART_TxFrames[m_EUART_TxFrm_Tail].len)		//Ò»Ö¡Êý¾Ý·¢ËÍÍê±Ï
	{
		s_count = 0;
		m_EUART_TxFrm_Tail++;
		if(m_EUART_TxFrm_Tail == EUART_TX_FRM_SIZE)
			m_EUART_TxFrm_Tail = 0;
		m_EUART_TxFrm_FreeFrmLen++;
	}
	m_bEUARTCheckingSend = 0;
 }		   // */

#else

//¼ì²éÊÇ·ñÊý¾ÝÖ¡ÐèÒª·¢ËÍ
void UART_CheckSend(void)
{
	//ÅжÏÊÇ·ñÕýÔÚCheck
	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	m_bEUARTCheckingSend = 1;

	//ÅжÏDMAͨµÀÊÇ·ñÕýÔÚ¹¤×÷
	if((EUART_TX_DMA_CH->CCR & 0x01) != 0)	//ͨµÀÕýÔÚ¹¤×÷
	{
		if((EUART_DMA->ISR & EUART_TX_DMA_IT_TC) == (uint32_t)RESET) 	//´«ÊäδÍê³É
		{
			m_bEUARTCheckingSend = 0;
			return;
		}
		else
		{
			EUART_DMA->IFCR = EUART_TX_DMA_IT_TC;				//Çå³ý±êÖ¾£¨×¢Òâ¼Ä´æÆ÷ºÍ±êÖ¾Ãû³Æ£©
			EUART_TX_DMA_CH->CCR &= ~((uint32_t)0x01);	//½ûÓÃDMA
		}
	}
	
	//Åж϶ÓÁÐÊÇ·ñΪ¿Õ
	if(m_EUART_TxFrm_Head == m_EUART_TxFrm_Tail)
	{
		m_bEUARTCheckingSend = 0;
		return;
	}
	
	//¿ªÆôÒ»´ÎÊý¾Ý·¢ËÍ
	EUART_TX_DMA_CH->CMAR = (uint32_t)m_EUART_TxFrames[m_EUART_TxFrm_Tail].buf;	//Òª·¢Ë͵ÄÄÚ´æµØÖ· 
	EUART_TX_DMA_CH->CNDTR = m_EUART_TxFrames[m_EUART_TxFrm_Tail].len;		//Òª·¢Ë͵Ä×Ö½ÚÊý
	EUART_TX_DMA_CH->CCR |= 0x01;											//¿ªÆôÒ»´ÎDMA  
	m_EUART_TxFrm_Tail++;
	if(m_EUART_TxFrm_Tail == EUART_TX_FRM_SIZE)
		m_EUART_TxFrm_Tail = 0;	
	m_EUART_TxFrm_FreeFrmLen++;
	m_bEUARTCheckingSend = 0;	 
}					// */	
#endif


//½«Ò»Ö¡Êý¾ÝѹÈë·¢ËͶÓÁÐ
void UART_PushFrame(uint8_t* pdata, int32_t data_len)
{
//	uint8_t temp8 = 0;
	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	m_bEUARTPushingFrms = 1;
	
	if(data_len > EUART_TX_FRMBUF_SIZE || m_EUART_TxFrm_FreeFrmLen <= 0)		//Ö¡³¤¶È³¬·¶Î§»ò»º´æÒÑÂú
	{
		m_bEUARTPushingFrms = 0;
		return;
	}

	//½«Òª·¢Ë͵ÄÊý¾Ý֡ѹÈë¶ÓÁÐ
	m_EUART_TxFrames[m_EUART_TxFrm_Head].len = data_len;
	memcpy((uint8_t*)m_EUART_TxFrames[m_EUART_TxFrm_Head].buf, (uint8_t*)pdata, data_len);
	m_EUART_TxFrm_Head++;
	if(m_EUART_TxFrm_Head == EUART_TX_FRM_SIZE)
		m_EUART_TxFrm_Head = 0;
	m_EUART_TxFrm_FreeFrmLen--;
	m_bEUARTPushingFrms = 0;	
	UART_CheckSend();
}

//½«×îÐÂÒ»Ö¡Êý¾ÝPop³ö¶ÓÁÐ
void UART_PopFrame(void)
{
	if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
		return;
	if(m_EUART_TxFrm_FreeFrmLen >= EUART_TX_FRM_SIZE-1)
		return;
	m_EUART_TxFrm_Head--;
	if(m_EUART_TxFrm_Head < 0)
		m_EUART_TxFrm_Head = EUART_TX_FRM_SIZE-1;
	m_EUART_TxFrm_FreeFrmLen++;
}
void USART_putc(char c)
{
	//while(!(USART2->SR & 0x00000040));
	//USART_SendData(USART2,c);
	/* e.g. write a character to the USART */
	USART_SendData(USART1, c);

	/* Loop until the end of transmission */
	while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)	;
}
void USART_puts(uint8_t *s,uint8_t len)
{
	int i;
	for(i=0; i<len; i++)
	{
		USART_putc(s[i]);
	}
}
int fputc(int ch, FILE *f)
{
	
	USART_SendData(USART1, (unsigned char) ch);// USART1 ???? USART2 ?
	while (!(USART1->SR & USART_FLAG_TXE));
	return (ch);
}