/**
  ******************************************************************************
  * @file           : functions.c
  * @brief          : funcstions program body
  ******************************************************************************
	*/
//#include "globaldef.h"
#include "functions.h"
#include "string.h"
#include "stm32f0xx_hal.h"
#if (BOARD_TYPE == 14)
#include "fp0.h"
#endif
extern __IO uint32_t uwTick;

unsigned char Uart3RxBuf[UART3RXBUFSIZE];
unsigned char Uart3TxBuf[UART3TXBUFSIZE];
stUartStat Uart3Stat={0};
unsigned int Uart3RecvBuf1DataLen =0;
unsigned int Uart3ToSendLen =0 ;
unsigned int Uart3SentLen = 0;

unsigned char Uart5RxBuf[UART5RXBUFSIZE];
unsigned char Uart5TxBuf[UART5TXBUFSIZE];
stUartStat Uart5Stat={0};
unsigned int Uart5RecvBuf1DataLen =0;
unsigned int Uart5ToSendLen =0 ;
unsigned int Uart5SentLen = 0;

unsigned char Uart6RxBuf[UART6RXBUFSIZE];
unsigned char Uart6TxBuf[UART6TXBUFSIZE];
stUartStat Uart6Stat={0};
unsigned int Uart6RecvBuf1DataLen =0;
unsigned int Uart6ToSendLen =0 ;
unsigned int Uart6SentLen = 0;

//#include "Myprotocol.h"
int TickFreq=10000;
int CoreClkMHz;		//=SystemCoreClock/1000000;
int TickPriodClk;		//=SystemCoreClock/TickFreq;
unsigned int TickPrioduS;	//
volatile unsigned int nCurTick=0;
volatile unsigned int CurTickuS=0;
//volatile unsigned int ThisRunTime=0;		//开机时间
//volatile unsigned int TotalRunTime=0; 	//总开机时间
//volatile unsigned int PwrCount=0;				//开机次数
unsigned short ClkuS;				//每个Clk的nS数，

int InituS(int TickFreq1)
{
		TickPrioduS=1000000/TickFreq1;	//每个SysTick的微秒数
		CoreClkMHz=HAL_RCC_GetHCLKFreq()/1000000;		//=SystemCoreClock/1000000;每uS的时钟数
		TickPriodClk=SystemCoreClock/TickFreq1;			//每个SysTick的时钟数
		ClkuS=(1000000LL*65536)/SystemCoreClock;
		CurTickuS=TickPrioduS+100u;
	return 0;
}

inline unsigned int GetuS(void)
{
//	unsigned short Clk1=SysTick->VAL;
	
	int CurTickuS1=CurTickuS;
	int Val1=SysTick->VAL;
	if (CurTickuS1 != CurTickuS )
	{
		CurTickuS1=CurTickuS;
		Val1=SysTick->VAL;
	}
	uint32_t us1=CurTickuS1-(((Val1)*1365)>>16);
	return us1;
}

inline unsigned int GetTick(void)
{
//	unsigned short Clk1=SysTick->VAL;
		return nCurTick;
}

void logData(unsigned char d)
{
			KMem.WDB[128+KMem.WDT[123]] = d;
			KMem.WDT[123]++; 	 if (KMem.WDT[123]>=100) {KMem.WDT[123]=81;}			
}

const unsigned short crc16_table[256] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};

unsigned short crc_check(const unsigned char * data, unsigned int  length)
{
unsigned short crc_reg = 0xFFFF;
	while (length--)
	{
	crc_reg = (crc_reg >> 8) ^ crc16_table[(crc_reg ^ *data++) & 0xff];
	}
	return (~crc_reg) & 0xFFFF;
}

const uint16_t polynom = 0xA001;
 
unsigned short crc16bitbybit(const unsigned char *ptr, unsigned int len)
{
	uint8_t i;
	uint16_t crc = 0xffff;
 
	if (len == 0) {
		len = 1;
	}
	while (len--) {
		crc ^= *ptr;
		for (i = 0; i<8; i++)
		{
			if (crc & 1) {
				crc >>= 1;
				crc ^= polynom;
			}
			else {
				crc >>= 1;
			}
		}
		ptr++;
	}
	return(crc);
}
 
/* Table of CRC values for high-order byte */
const uint8_t crctablehi[] = {
	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
};
/* Table of CRC values for low-order byte */
const uint8_t crctablelo[] = {
	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
};
 
uint16_t crc16table(const uint8_t *ptr, uint16_t len)
{
	uint8_t crchi = 0xff;
	uint8_t crclo = 0xff; 
	uint16_t index;
	while (len--) 
	{
		index = crclo ^ *ptr++; 
		crclo = crchi ^ crctablehi[index];
		crchi = crctablelo[index];
	}
	return (crchi << 8 | crclo);
}
 
void modbuscrc16test()
{
	printf("\n");
	printf(" Modbus CRC16 tester\n");
	printf("-----------------------------------------------------------------------\n");
	uint8_t crc16_data[] = { 0x01, 0x04, 0x04, 0x43, 0x6b, 0x58, 0x0e };	// expected crc value 0xD825.
	printf(" modbus crc16table test, expected value : 0xd825, calculate value : 0x%x\n", crc16table(crc16_data, sizeof(crc16_data)));
//	printf(" modbus crc16tablefast test, expected value : 0xd825, calculate value : 0x%x\n", crc16tablefast(crc16_data, sizeof(crc16_data)));
	printf(" modbus crc16bitbybit test, expected value : 0xd825, calculate value : 0x%x\n", crc16bitbybit(crc16_data, sizeof(crc16_data)));
}

int InitUartstat(stUartStat * pUartstat,void * pBufRx, int nSizeRx, void * pBufTx, int nSizeTx)
{
	memset(pUartstat,sizeof(stUartStat),0);
	initQueue(&pUartstat->QRx,pBufRx,nSizeRx);
	initQueue(&pUartstat->QTx,pBufTx,nSizeTx);
	return 0;
}

int Uart1SendDMA(void * pData, int nSize)
{
	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_2);
	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_2, (uint32_t)pData,
         (uint32_t)&USART1->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_2,nSize);
	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_2);
	Uart1Stat.DMASendLen=nSize;
	Uart1Stat.bSending=1;	
	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_2);
	LL_USART_EnableDMAReq_TX(USART1);
	return nSize;	
}

int Uart1TriggerSendDMA()
{
		if (!Uart1Stat.bSending&&!IsEmpty(&Uart1Stat.QTx))
		{			
			int len1=GetContinueData(&Uart1Stat.QTx);
			Uart1SendDMA(GetReadBuffer(&Uart1Stat.QTx),len1);
		}
		return 0;
}

void Uart2SetDE(void)
{
	LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_1);
}
void Uart2UnsetDE(void)
{
	LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_1);
}
void DelayUs(int nUs)
{
	for (int i=0;i<nUs;i++)
	 for (volatile int j=0;j<24;j++)
		{
			__nop();
		}
}

int Uart2RecvDMA(void * pBuf, int nSize)
{
	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_5);
	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_5, (uint32_t)&USART2->RDR,
         (uint32_t)pBuf, LL_DMA_DIRECTION_PERIPH_TO_MEMORY);
	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_5,nSize);
	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_5);
	Uart2Stat.DMARecvLen=nSize;
	Uart2Stat.bRecving=1;	
	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_5);
	LL_USART_EnableDMAReq_RX(USART2);	
	return 0;
}
int Uart2SendDMA(void * pData, int nSize)
{
#if (USART2_USE_HARDWARE_DE == 1)

#else
		Uart2SetDE();
		DelayUs(USART2_DE_ASSERTION_TIME);
#endif	
	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_4, (uint32_t)pData,
         (uint32_t)&USART2->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_4,nSize);
	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);
	Uart2Stat.DMASendLen=nSize;
	Uart2Stat.bSending=1;	
	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_4);
	LL_USART_EnableDMAReq_TX(USART2);
	return nSize;	
}
int Uart2TriggerSendDMA()
{
		if (!Uart2Stat.bSending&&!IsEmpty(&Uart2Stat.QTx))
		{			
			int len1=GetContinueData(&Uart2Stat.QTx);
			Uart2SendDMA(GetReadBuffer(&Uart2Stat.QTx),len1);
		}
		return 0;
}

void TriggerPendSV()
{
	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
}


void SPI1_IRQ_CallBack()
{
		uint8_t value;
//	LL_GPIO_TogglePin(GPIOB,LL_GPIO_PIN_7);
	if (LL_SPI_IsActiveFlag_RXNE(SPI1))
	{
		value = LL_SPI_ReceiveData8( SPI1);
#if (BOARD_TYPE == 14)
			KMem.WDD[62]++;
			KMem.WDT[122]++;
		 if (!bSPI1Sending)
		 {
			 logData(value);
		 }
		 if (!bSPI1Sending && (1 || bSPI1Recving))
		 {
			 SPI1RecvBuf[nSPI1RecvPos]=value;
			 nSPI1RecvPos++;
			 
			 if (value==0x0d)
			 {
				 logData(nSPI1RecvPos);

				 nSPI1RecvLenInBuf=nSPI1RecvPos;
				 bSPI1RecvDone=1;
				 nSPI1RecvPos=0;
				 bSPI1Recving=0;
			 
				 TriggerPendSV();
			 }
		 }
		 if (bSPI1Sending)
		 {
				 nSPI1SentLen++;
				 KMem.SDD[63]++;
			 
			 if (nSPI1SentLen >= nSPI1ToSendLen) {
				 SetACKPin_1();
				 bSPI1Sending=0;
				 bSPI1SendDone=1;
				 bSPI1Recving=1;
				 nSPI1RecvPos=0;
				 SetFP0DEPin_0();
			 }
			 else {
				 value = SPI1SendBuf[nSPI1SentLen];
				 LL_SPI_TransmitData8(SPI1,value);
				logData(value);
			 }
		 }
#endif		 
	 }	 
}

void Uart1SendDone()
{
	Uart1Stat.TcCount++;
	return;
}

void Uart1RecvDone()
{
		Uart1Stat.IdelCount++;
//		NVIC_SetPendingIRQ(PendSV_IRQn);
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	
	if (Uart1RecvBuf1DataLen >0)
	{
		Uart1Stat.bPacketRecved=1;
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
//		KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
//		Uart1RecvBuf1DataLen=0;
	}
}

void Uart2SendDone()
{
	Uart2Stat.TcCount++;
#if (USART2_USE_HARDWARE_DE == 1)
#else
Uart2UnsetDE();
#endif
}
void Uart2RecvDone()
{
	Uart2RecvBuf1DataLen=sizeof(Uart2RecvBuf1) - LL_DMA_GetDataLength(DMA1,LL_DMA_CHANNEL_5);
	Uart2Stat.bPacketRecved=1;
	Uart2Stat.IdelCount++;
	if (Uart2RecvBuf1DataLen>0)
		TriggerPendSV();
	//	ParsePacket((pKBPacket)Uart2RecvBuf1,Uart2RecvBuf1DataLen);
}

void Uart3SendDone()
{
//	Uart1Stat.TcCount++;
	return;
}

void Uart3RecvDone()
{
//		Uart3Stat.IdelCount++;
//		NVIC_SetPendingIRQ(PendSV_IRQn);
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	
	if (Uart3RecvBuf1DataLen >0)
	{
		Uart3Stat.bPacketRecved=1;
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
//		KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
//		Uart1RecvBuf1DataLen=0;
	}
}
void Uart3SendPacket(char * str, int len)
{
	memcpy(Uart3TxBuf,str,len);
	Uart3ToSendLen = len;
	LL_USART_EnableIT_TXE(USART3);
}

void Uart5SendDone()
{
//	Uart1Stat.TcCount++;
	return;
}

void Uart5RecvDone()
{
//		Uart5Stat.IdelCount++;
//		NVIC_SetPendingIRQ(PendSV_IRQn);
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	
	if (Uart5RecvBuf1DataLen >0)
	{
		Uart5Stat.bPacketRecved=1;
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
//		KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
//		Uart1RecvBuf1DataLen=0;
	}
}
void Uart5SendPacket(char * str, int len)
{
	memcpy(Uart5TxBuf,str,len);
	Uart5ToSendLen = len;
	
	LL_USART_EnableIT_TXE(USART5);
}

void Uart6SendDone()
{
//	Uart1Stat.TcCount++;
	return;
}

void Uart6RecvDone()
{
//		Uart5Stat.IdelCount++;
//		NVIC_SetPendingIRQ(PendSV_IRQn);
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	
	if (Uart6RecvBuf1DataLen >0)
	{
		Uart6Stat.bPacketRecved=1;
//	  SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
//		KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
//		Uart1RecvBuf1DataLen=0;
	}
}
void Uart6SendPacket(unsigned char * str, int len)
{
	memcpy(Uart6TxBuf,str,len);
	Uart6ToSendLen = len;
	
	LL_USART_EnableIT_TXE(USART6);
}

void SLPSendPacket(void * str, uchar len)
{
	Uart6SendPacket(str,len);
}


int PutStr(char * str1, int len1)
{
//	Uart1SendDMA(str1,len1);
	PushIn(&Uart1Stat.QTx,str1,len1);
//	LL_USART_EnableIT_TXE(USART1);   
//	LL_USART_EnableIT_TC(USART1); 	
	Uart1TriggerSendDMA();
	return len1;
}
int PutStr1(char * str1, int len1)
{
//	Uart1SendDMA(str1,len1);
	PushIn(&Uart1Stat.QTx,str1,len1);
//	LL_USART_EnableIT_TXE(USART1);   
//	LL_USART_EnableIT_TC(USART1); 	
	Uart1TriggerSendDMA();
	return len1;
}
int PutStr2(char * str1, int len1)
{
	Uart2SendDMA(str1,len1);
//	PushIn(&Uart2Stat.QTx,str1,len1);
//	LL_USART_EnableIT_TXE(USART1);   
//	LL_USART_EnableIT_TC(USART1); 	
//	Uart2TriggerSendDMA();
	return len1;
}

int SendPacket(int nChn, void * pBuf,int len1)
{
	if (nChn==1) 	{
		PutStr1((char *)pBuf,len1);
//	PushIn(&Uart1Stat.QTx,p1,len1);
//	Uart1TriggerSendDMA();
		Uart1Stat.SentPacket++;		
	}else if (nChn==2){
		PutStr2((char *)pBuf,len1);	
//	PushIn(&Uart2Stat.QTx,p1,len1);
//	Uart2TriggerSendDMA();	
		Uart2Stat.SentPacket++;		
	}
		return len1;
}
/*
int SendPacket1(void * pBuf,int len1)
{
		PutStr1((char *)pBuf,len1);
//	PushIn(&Uart1Stat.QTx,p1,len1);
//	Uart1TriggerSendDMA();
		Uart1Stat.SentPacket++;
	return len1;
}
int SendPacket2(pKBPacket p1,int len1)
{
		PutStr2((char *)p1,len1);	
//	PushIn(&Uart2Stat.QTx,p1,len1);
//	Uart2TriggerSendDMA();	
		Uart2Stat.SentPacket++;
	return len1;
}
*/
void ToggleRunLed() {	LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_13);}
void ToggleErrLed() {	LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_14);}
void ToggleErr2Led() {	LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}

#if (BOARD_TYPE == 14)
void ToggleOutStat() {	LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}

void SetOutStat(uchar bOn)
{
	if (bOn) {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	else {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}	
}
#else
void ToggleOutStat() {	LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_11);}

void SetOutStat(uchar bOn)
{
	if (bOn) {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_11);}
	else {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_11);}	
}
#endif

void SetRunLed(uchar bOn)
{
	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_13);}
	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_13);}		
}
void SetErrLed(uchar bOn)
{
	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_14);}
	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_14);}		
}
void SetErr2Led(uchar bOn)
{
	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}		
}
/*
void SetLeds(uchar bRun, uchar bErr)
{
	SetRunLed(bRun); SetErrLed (bErr);
}
*/

#define set165SL_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_4)
#define set165SL_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_4)
#define set165CLK_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_5)
#define set165CLK_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_5)
#define Get165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_6)
#define GetCfg165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_7)

unsigned int Input165_8()
{
	int x1=0;
	__disable_irq();
	set165SL_0();	set165SL_1();
	unsigned int mask1=0x0080;
	volatile uint32_t * p1=&GPIOA->IDR;
	for (uint32_t i=8;i;i--)
	{
		//if (Get165SER()) {}
		//else x1|=mask1;
		if (*p1&LL_GPIO_PIN_6) {}
		else x1|=mask1;			
		//x1<<=1;
		//x1|=!Get165SER();
		set165CLK_0();			
		mask1>>=1;
		set165CLK_1();
	}
	__enable_irq();
	return x1;
}

unsigned int Input165(int nBit)
{
	int x1=0;
	__disable_irq();
	set165SL_0();	set165SL_1();
	unsigned int mask1=1<<(nBit-1);
	volatile uint32_t * p1=&GPIOA->IDR;
	for (uint32_t i=nBit;i;i--)
	{
		//if (Get165SER()) {}
		//else x1|=mask1;
		if (*p1&LL_GPIO_PIN_6) {}
		else x1|=mask1;			
		//x1<<=1;
		//x1|=!Get165SER();
		set165CLK_0();	
		mask1>>=1;
		set165CLK_1();
	}
	__enable_irq();
	return x1;
}
unsigned int Input165_R(int nBit)
{
	__disable_irq();
	set165SL_0();	set165SL_1();
	int nBytes = nBit /8;
	volatile uint32_t * p1=&GPIOA->IDR;
	union stdata
	{
		int intvalue;
		unsigned char Bytes[4];
	}rdata;
	rdata.intvalue=0;
	for (int i=0;i<nBytes;i++)
	{
		int x1=0;
		unsigned int mask1=1<<(7);
		for (uint32_t i=8;i;i--)
		{
			//if (Get165SER()) {}
			//else x1|=mask1;
			if (*p1&LL_GPIO_PIN_6) {}
			else x1|=mask1;			
			//x1<<=1;
			//x1|=!Get165SER();
			set165CLK_0();	
			mask1>>=1;
			set165CLK_1();
		}
		rdata.Bytes[i]=x1;
	}
	__enable_irq();
	return rdata.intvalue;
}

#define set165SL_C0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_12)
#define set165SL_C1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_12)
#define set165CLK_C0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_13)
#define set165CLK_C1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_13)
#define Get165SER_C() LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_14)


unsigned int Input165_C(int nBit)
{
	__disable_irq();
	set165SL_C0();	
	__nop();
	__nop();
	__nop();
	__nop();
	
	set165SL_C1();
	int nBytes = nBit /8;
	volatile uint32_t * p1=&GPIOB->IDR;
	union stdata
	{
		int intvalue;
		unsigned char Bytes[4];
	}rdata;
	rdata.intvalue=0;
	for (int i=0;i<nBytes;i++)
	{
		int x1=0;
		unsigned int mask1=1<<(7);
		for (uint32_t i=8;i;i--)
		{
			//if (Get165SER()) {}
			//else x1|=mask1;
			if (*p1&LL_GPIO_PIN_14) {x1|=mask1;}
			else {};			
			//x1<<=1;
			//x1|=!Get165SER();
			set165CLK_C0();	
			mask1>>=1;
			__nop();
			__nop();
			__nop();
			__nop();
			__nop();
				
			set165CLK_C1();
		}
/*		
		LL_SPI_TransmitData8(SPI2,0xff);
	while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
	{
	}
	while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
	{
	}			
		x1 = LL_SPI_ReceiveData8(SPI2);
*/		
		rdata.Bytes[i]=~x1;
//		rdata.Bytes[i]=0;
	
	}
	__enable_irq();
	return rdata.intvalue;
}

unsigned int Input165Cfg(int nBit)
{
	int x1=0;
	__disable_irq();
	set165SL_0();	set165SL_1();
	unsigned int mask1=1<<(nBit-1);
	volatile uint32_t * p1=&GPIOA->IDR;
	for (uint32_t i=nBit;i;i--)
	{
		//if (Get165SER()) {}
		//else x1|=mask1;
		if (*p1&LL_GPIO_PIN_7) {}
		else x1|=mask1;			
		//x1<<=1;
		//x1|=!Get165SER();
		set165CLK_0();	
		mask1>>=1;
		set165CLK_1();
	}
	__enable_irq();
	return x1;
}

unsigned int GetInput()
{
	int BoradType=GetBoardType();
	switch (BoradType)
	{
		
		case 1:
					 return Input165(8);
		case 2:
					 return Input165(8);
		case 3:
					 return Input165(16);
		case 4:
					 return Input165(8);
		case 5:
		case 7:
						return Input165(16);
		case 6:
		case 8:
						return Input165(8);
		case 9:
						return Input165_R(16);
		case 10:
						return Input165_R(8);
		case 11:
						return Input165_R(8);
		case 13:
						return Input165_R(16);
		case 14:
						return 0;	//FP0
		case 15:
						return Input165_R(16);
		case 16:
						return Input165_R(8);

		case 17:
						return Input165_C(8);
		
		default:
			break;
	}
		return 0;
		
}
int ReadConfig_0()
{
	return 0;
}

int ReadConfig_1()
{
	//	uchar x = LL_GPIO_ReadInputPort(GPIOB);
//	uchar x1 = LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_10);
//	uchar x2=(x&0x7) | (x1 << 3 ) ;	
	uchar x2=0;
	x2=(GPIOB->IDR&0x7) | ((GPIOB->IDR &0x400)>>7); 
	x2= (~x2)&0xf;
	return x2;
}

int ReadConfig_2()
{
	uchar x2=0;
	x2=(GPIOB->IDR&0x7) | ((GPIOB->IDR &0x400)>>7); 
	x2= (~x2)&0xf;
	return x2;
}

int ReadConfig_3()
{
	uchar x2=0;
	x2 = Input165(24)&0xff;
	return x2;
	
}
int ReadConfig_4()
{
	
	uchar x2=0;
	x2 = Input165(16)&0xff;
	return x2;
}

int ReadConfig_5()
{
	uchar x2=0;
	x2 = Input165Cfg(8)&0xff;
	return x2;
}

int ReadConfig_11()
{
	uchar x2=0;
	x2=((GPIOB->IDR&0x6)<<4); 
	x2= ((~x2)&0x30)|1;
	return x2;
}	

int ReadConfig_17()
{
	shortbits v1;
	v1.value=0;
	shortbits x2;
	x2.value=GPIOA->IDR; 
	v1.bit8 = ~x2.bit6;
	v1.bit9 = ~x2.bit7; 
	v1.bit10 = ~x2.bit15;
	x2.value=GPIOB->IDR; 
	v1.bit11 = ~x2.bit1;
	v1.bit12 = ~x2.bit2;
	
	v1.bit0 = ~x2.bit5;
	v1.bit1 = ~x2.bit6;
	v1.bit2 = ~x2.bit7;
	v1.bit3 = ~x2.bit8;
	v1.bit4 = ~x2.bit9;
	x2.value=GPIOC->IDR; 
	v1.bit13 = ~x2.bit15;

	return v1.value;
}	

int ReadJumperSW()
{
		int BoradType=GetBoardType();
	switch (BoradType)
	{
		case 0:
					return ReadConfig_0();	
		case 1:
					 return ReadConfig_1();	//old board 4 in 4 o
		case 2:
					 return ReadConfig_2();	//old board 8 in 8 o
		case 3:
					 return ReadConfig_3();	//Master 16 in16 o
		case 4:
					 return ReadConfig_4();	//Slave 8 in 8 o
		case 5:
		case 7:
					 return ReadConfig_5();	// New Master 16 in16 o
		case 6:
		case 8:
					 return ReadConfig_5();	//New Slave 8 in 8 o
		case 9:
		case 10:
					 return ReadConfig_5();	//New Master Slave 8 in 8 o
		case 11:
					 return ReadConfig_11(); //Mini Board
		case 13:
					 return ReadConfig_5();
		case 14:
					 return (~(LL_GPIO_ReadInputPort(GPIOA)>>4))&0x0f;	//FP0
		case 15:
		case 16:
					 return ReadConfig_5();	//Wireless Master Slave 8 in 8 o
		case 17:
					 return ReadConfig_17();	//Wireless Master Slave 8 in 8 o		
		default:
			
					 return 0;
	}
}

#define SRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_13)
#define SRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_13)
#define STRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_12)
#define STRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_12)
#define SER2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_15)
#define SER2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_15)

void Enable595(uchar bEnable)
{
			if (bEnable) {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_8);}
			else {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_8);}	
}

void Output595_8(unsigned int cc)
{
//unsigned char i;
;//		74HC595输出程序，输出8位
//	cc=~0x3f;
	__disable_irq();
	STRCLK2_1();
	unsigned int mask1=0x0080;
	//volatile uint32_t * p1 = &GPIOB->BRR;
	//volatile uint32_t * p2 = &GPIOB->BSRR;
	for (;mask1;)
	{
		SRCLK2_0();
		//*p1=LL_GPIO_PIN_13;
		if (cc&mask1) {SER2_1();}
		else {SER2_0();}
		mask1>>=1;
		SRCLK2_1();
//		__nop();
		//*p2=LL_GPIO_PIN_13;
	}
	STRCLK2_0();
	STRCLK2_1();	
	__enable_irq();
}

void Output595_16(unsigned int cc)
{
//unsigned char i;
;//		74HC595输出程序，输出16位
//	cc=~0x3f;
	__disable_irq();
	STRCLK2_1();
	unsigned int mask1=0x8000;
	//volatile uint32_t * p1 = &GPIOB->BRR;
	//volatile uint32_t * p2 = &GPIOB->BSRR;
	for (;mask1;)
	{
		SRCLK2_0();
		//*p1=LL_GPIO_PIN_13;
		if (cc&mask1) {SER2_1();}
		else {SER2_0();}
		mask1>>=1;
		SRCLK2_1();
//		__nop();
		//*p2=LL_GPIO_PIN_13;
	}
	STRCLK2_0();
	STRCLK2_1();
	__enable_irq();
}

/*
#define STRCLK12_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_7)
#define STRCLK12_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_7)

void PutOutputSPI1(unsigned int Y)
{
	__disable_irq();
	STRCLK12_1();	
	LL_SPI_TransmitData8(SPI1,Y>>8);
	int i=0;
	while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
	{
	}
	KMem.SDD[28]=i;
	i=0;
	while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
	{
		i++;
	}	
	LL_SPI_TransmitData8(SPI1,Y);
	while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
	{
	}
	KMem.SDD[28]=i;
	i=0;
	while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
	{
		i++;
	}		
	KMem.SDD[30]=i;
		STRCLK12_0();
		__nop();
		STRCLK12_1();
		__enable_irq();
}
*/

void PutOutputSPI2(unsigned int Y)
{
	__disable_irq();
	STRCLK2_1();	
	LL_SPI_TransmitData8(SPI2,Y>>8);
	int i=0;
	while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
	{
	}
	KMem.SDD[28]=i;
	i=0;
	while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
	{
		i++;
	}	
	LL_SPI_TransmitData8(SPI2,Y);
	while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
	{
	}
	KMem.SDD[28]=i;
	i=0;
	while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
	{
		i++;
	}		
	KMem.SDD[30]=i;
		STRCLK2_0();
		STRCLK2_1();
	__enable_irq();
}

void PutOutput(unsigned int Y)		
{	
#if (BOARD_TYPE == 14)
	return ;
#else
//	PutOutputSPI2(Y);
	Output595_8(Y);
#endif
}

#if (BOARD_TYPE == 9 || BOARD_TYPE == 10 || BOARD_TYPE == 15 ||  BOARD_TYPE == 16)
//#pragma message("9,10")
	// V4.2 管脚排列向右移动了一位。
#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_11)
#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_11)
#else		//按照原来的管脚排列
#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_0)
#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_0)
#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
#endif


void EnableDisIn(uchar bEnable)
{
			if (bEnable) {OE1_0();}
			else {OE1_1();}	
}
/*
void displayInput(unsigned int cc)
{
//unsigned char i;
;//		74HC595输出程序，输出8位
//	cc=~0x3f;
	__disable_irq();
	STRCLK1_1();
	unsigned int mask1=0x8000;
	//volatile uint32_t * p1 = &GPIOB->BRR;
	//volatile uint32_t * p2 = &GPIOB->BSRR;`````
	for (;mask1;)
	{
		SRCLK1_0();
		// *p1=LL_GPIO_PIN_13;
		if (cc&mask1) {SER1_1();}
		else {SER1_0();}
		mask1>>=1;
		SRCLK1_1();
//		__nop();
		// *p2=LL_GPIO_PIN_13;
	}
	STRCLK1_0();
	STRCLK1_1();
	__enable_irq();	
}
*/