F030C8T6_Kbus_MIX.git

QuakeGod

2024-07-27 842bb64195f958b050867c50db66fc0aa413dafb

提交 \| 用户 \| age
483170	1	/**
Q	2	******************************************************************************
	3	* @file : functions.c
	4	* @brief : funcstions program body
	5	******************************************************************************
	6	*/
	7	//#include "globaldef.h"
	8	#include "functions.h"
	9	#include "string.h"
	10	#include "stm32f0xx_hal.h"
	11	#if (BOARD_TYPE == 14)
5dd1b7	12	#include "fpx.h"
483170	13	#endif
Q	14	extern __IO uint32_t uwTick;
	15	//#include "Myprotocol.h"
	16	int TickFreq=10000;
	17	int CoreClkMHz; //=SystemCoreClock/1000000;
	18	int TickPriodClk; //=SystemCoreClock/TickFreq;
	19	unsigned int TickPrioduS; //
	20	volatile unsigned int nCurTick=0;
	21	volatile unsigned int CurTickuS=0;
	22	//volatile unsigned int ThisRunTime=0; //开机时间
	23	//volatile unsigned int TotalRunTime=0; //总开机时间
	24	//volatile unsigned int PwrCount=0; //开机次数
	25	unsigned short ClkuS; //每个Clk的nS数，
5dd1b7	26
Q	27	unsigned char SPI1RecvBuf[64];
	28	unsigned char SPI1SendBuf[64];
	29
	30	volatile unsigned char bSPI1Recving=0;
	31	volatile unsigned char bSPI1RecvDone =0;
	32
	33	volatile unsigned char nSPI1RecvPos =0;
	34	volatile unsigned char nSPI1RecvLenInBuf=0;
	35
	36	volatile unsigned char nSPI1ToSendLen=0;
	37	volatile unsigned char nSPI1SentLen=0;
	38
	39	volatile unsigned char bSPI1Sending=0;
	40	volatile unsigned char bSPI1SendDone=0;
	41
483170	42
Q	43	int InituS(int TickFreq1)
	44	{
	45	TickPrioduS=1000000/TickFreq1; //每个SysTick的微秒数
	46	CoreClkMHz=HAL_RCC_GetHCLKFreq()/1000000; //=SystemCoreClock/1000000;每uS的时钟数
	47	TickPriodClk=SystemCoreClock/TickFreq1; //每个SysTick的时钟数
	48	ClkuS=(1000000LL*65536)/SystemCoreClock;
	49	CurTickuS=TickPrioduS+100u;
	50	return 0;
	51	}
	52
	53	inline unsigned int GetuS(void)
	54	{
	55	// unsigned short Clk1=SysTick->VAL;
	56
	57	int CurTickuS1=CurTickuS;
	58	int Val1=SysTick->VAL;
	59	if (CurTickuS1 != CurTickuS )
	60	{
	61	CurTickuS1=CurTickuS;
	62	Val1=SysTick->VAL;
	63	}
	64	uint32_t us1=CurTickuS1-(((Val1)*1365)>>16);
	65	return us1;
	66	}
	67
	68	inline unsigned int GetTick(void)
	69	{
	70	// unsigned short Clk1=SysTick->VAL;
	71	return nCurTick;
	72	}
	73
	74	void logData(unsigned char d)
	75	{
842bb6	76	KMem.WDB[128+KMem.WDT[7]] = d;
Q	77	KMem.WDT[7]++; if (KMem.WDT[7]>=100) {KMem.WDT[7]=81;}
483170	78	}
Q	79
842bb6	80	/*
483170	81	const unsigned short crc16_table[256] = {
Q	82	0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
	83	0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
	84	0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
	85	0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
	86	0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
	87	0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
	88	0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
	89	0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
	90	0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
	91	0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
	92	0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
	93	0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
	94	0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
	95	0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
	96	0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
	97	0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
	98	0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
	99	0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
	100	0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
	101	0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
	102	0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
	103	0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
	104	0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
	105	0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
	106	0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
	107	0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
	108	0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
	109	0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
	110	0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
	111	0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
	112	0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
	113	0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
	114	};
	115
	116	unsigned short crc_check(const unsigned char * data, unsigned int length)
	117	{
	118	unsigned short crc_reg = 0xFFFF;
	119	while (length--)
	120	{
	121	crc_reg = (crc_reg >> 8) ^ crc16_table[(crc_reg ^ *data++) & 0xff];
	122	}
	123	return (~crc_reg) & 0xFFFF;
	124	}
	125
	126	const uint16_t polynom = 0xA001;
	127
	128	unsigned short crc16bitbybit(const unsigned char *ptr, unsigned int len)
	129	{
	130	uint8_t i;
	131	uint16_t crc = 0xffff;
	132
	133	if (len == 0) {
	134	len = 1;
	135	}
	136	while (len--) {
	137	crc ^= *ptr;
	138	for (i = 0; i<8; i++)
	139	{
	140	if (crc & 1) {
	141	crc >>= 1;
	142	crc ^= polynom;
	143	}
	144	else {
	145	crc >>= 1;
	146	}
	147	}
	148	ptr++;
	149	}
	150	return(crc);
	151	}
842bb6	152	*/
483170	153	/* Table of CRC values for high-order byte */
Q	154	const uint8_t crctablehi[] = {
	155	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
	156	0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
	157	0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
	158	0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41,
	159	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81,
	160	0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0,
	161	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
	162	0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40,
	163	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
	164	0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
	165	0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01,
	166	0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
	167	0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
	168	0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0,
	169	0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01,
	170	0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41,
	171	0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81,
	172	0x40
	173	};
	174	/* Table of CRC values for low-order byte */
	175	const uint8_t crctablelo[] = {
	176	0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4,
	177	0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09,
	178	0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD,
	179	0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3,
	180	0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7,
	181	0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A,
	182	0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE,
	183	0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26,
	184	0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2,
	185	0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F,
	186	0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB,
	187	0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5,
	188	0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91,
	189	0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C,
	190	0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88,
	191	0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C,
	192	0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
	193	0x40
	194	};
	195
	196	uint16_t crc16table(const uint8_t *ptr, uint16_t len)
	197	{
	198	uint8_t crchi = 0xff;
	199	uint8_t crclo = 0xff;
	200	uint16_t index;
	201	while (len--)
	202	{
	203	index = crclo ^ *ptr++;
	204	crclo = crchi ^ crctablehi[index];
	205	crchi = crctablelo[index];
	206	}
	207	return (crchi << 8 \| crclo);
	208	}
842bb6	209	/*
483170	210	void modbuscrc16test()
Q	211	{
	212	printf("\n");
	213	printf(" Modbus CRC16 tester\n");
	214	printf("-----------------------------------------------------------------------\n");
	215	uint8_t crc16_data[] = { 0x01, 0x04, 0x04, 0x43, 0x6b, 0x58, 0x0e }; // expected crc value 0xD825.
	216	printf(" modbus crc16table test, expected value : 0xd825, calculate value : 0x%x\n", crc16table(crc16_data, sizeof(crc16_data)));
	217	// printf(" modbus crc16tablefast test, expected value : 0xd825, calculate value : 0x%x\n", crc16tablefast(crc16_data, sizeof(crc16_data)));
	218	printf(" modbus crc16bitbybit test, expected value : 0xd825, calculate value : 0x%x\n", crc16bitbybit(crc16_data, sizeof(crc16_data)));
	219	}
842bb6	220	*/
483170	221	int InitUartstat(stUartStat * pUartstat,void * pBufRx, int nSizeRx, void * pBufTx, int nSizeTx)
Q	222	{
	223	memset(pUartstat,sizeof(stUartStat),0);
842bb6	224	if (pBufRx) initQueue(&pUartstat->QRx,pBufRx,nSizeRx);
Q	225	if (pBufTx) initQueue(&pUartstat->QTx,pBufTx,nSizeTx);
483170	226	return 0;
Q	227	}
	228
	229	int Uart1SendDMA(void * pData, int nSize)
	230	{
	231	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_2);
	232	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_2, (uint32_t)pData,
	233	(uint32_t)&USART1->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
	234	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_2,nSize);
	235	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_2);
	236	Uart1Stat.DMASendLen=nSize;
	237	Uart1Stat.bSending=1;
	238	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_2);
	239	LL_USART_EnableDMAReq_TX(USART1);
	240	return nSize;
	241	}
	242
	243	int Uart1TriggerSendDMA()
	244	{
	245	if (!Uart1Stat.bSending&&!IsEmpty(&Uart1Stat.QTx))
	246	{
	247	int len1=GetContinueData(&Uart1Stat.QTx);
	248	Uart1SendDMA(GetReadBuffer(&Uart1Stat.QTx),len1);
	249	}
	250	return 0;
	251	}
	252
	253	void Uart2SetDE(void)
	254	{
	255	LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_1);
	256	}
	257	void Uart2UnsetDE(void)
	258	{
	259	LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_1);
	260	}
	261	void DelayUs(int nUs)
	262	{
	263	for (int i=0;i<nUs;i++)
	264	for (volatile int j=0;j<24;j++)
	265	{
	266	__nop();
	267	}
	268	}
	269
	270	int Uart2RecvDMA(void * pBuf, int nSize)
	271	{
	272	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_5);
	273	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_5, (uint32_t)&USART2->RDR,
	274	(uint32_t)pBuf, LL_DMA_DIRECTION_PERIPH_TO_MEMORY);
	275	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_5,nSize);
	276	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_5);
	277	Uart2Stat.DMARecvLen=nSize;
	278	Uart2Stat.bRecving=1;
	279	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_5);
	280	LL_USART_EnableDMAReq_RX(USART2);
	281	return 0;
	282	}
	283	int Uart2SendDMA(void * pData, int nSize)
	284	{
	285	#if (USART2_USE_HARDWARE_DE == 1)
	286
	287	#else
	288	Uart2SetDE();
	289	DelayUs(USART2_DE_ASSERTION_TIME);
	290	#endif
	291	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
	292	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_4, (uint32_t)pData,
	293	(uint32_t)&USART2->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
	294	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_4,nSize);
	295	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);
	296	Uart2Stat.DMASendLen=nSize;
	297	Uart2Stat.bSending=1;
	298	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_4);
	299	LL_USART_EnableDMAReq_TX(USART2);
	300	return nSize;
	301	}
	302	int Uart2TriggerSendDMA()
	303	{
	304	if (!Uart2Stat.bSending&&!IsEmpty(&Uart2Stat.QTx))
	305	{
	306	int len1=GetContinueData(&Uart2Stat.QTx);
	307	Uart2SendDMA(GetReadBuffer(&Uart2Stat.QTx),len1);
	308	}
	309	return 0;
	310	}
	311
	312	void TriggerPendSV()
	313	{
	314	SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	315	}
	316
	317	void SPI1_IRQ_CallBack()
	318	{
	319	uint8_t value;
	320	// LL_GPIO_TogglePin(GPIOB,LL_GPIO_PIN_7);
	321	if (LL_SPI_IsActiveFlag_RXNE(SPI1))
	322	{
	323	value = LL_SPI_ReceiveData8( SPI1);
	324	#if (BOARD_TYPE == 14)
	325	KMem.WDD[62]++;
	326	KMem.WDT[122]++;
	327	if (!bSPI1Sending)
	328	{
	329	logData(value);
	330	}
	331	if (!bSPI1Sending && (1 \|\| bSPI1Recving))
	332	{
	333	SPI1RecvBuf[nSPI1RecvPos]=value;
	334	nSPI1RecvPos++;
	335
	336	if (value==0x0d)
	337	{
	338	logData(nSPI1RecvPos);
	339
	340	nSPI1RecvLenInBuf=nSPI1RecvPos;
	341	bSPI1RecvDone=1;
	342	nSPI1RecvPos=0;
	343	bSPI1Recving=0;
	344
	345
	346	TriggerPendSV();
	347	}
	348	}
	349	if (bSPI1Sending)
	350	{
	351	nSPI1SentLen++;
	352	KMem.SDD[63]++;
	353
	354	if (nSPI1SentLen >= nSPI1ToSendLen) {
	355	SetACKPin_1();
	356	bSPI1Sending=0;
	357	bSPI1SendDone=1;
	358	bSPI1Recving=1;
	359	nSPI1RecvPos=0;
5dd1b7	360	SetFPxDEPin_0();
483170	361	}
Q	362	else {
	363	value = SPI1SendBuf[nSPI1SentLen];
	364	LL_SPI_TransmitData8(SPI1,value);
	365	logData(value);
	366	}
	367	}
842bb6	368	#else
Q	369	UNUSED(value);
	370	#endif
483170	371	}
Q	372	}
	373
	374	void Uart1SendDone()
	375	{
	376	Uart1Stat.TcCount++;
	377	return;
	378	}
	379
	380	void Uart1RecvDone()
	381	{
	382	Uart1Stat.IdelCount++;
	383	// NVIC_SetPendingIRQ(PendSV_IRQn);
	384	// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	385
	386	if (Uart1RecvBuf1DataLen >0)
	387	{
	388	Uart1Stat.bPacketRecved=1;
	389	// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	390	// KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
	391	// Uart1RecvBuf1DataLen=0;
	392	}
	393	}
	394
	395	void Uart2SendDone()
	396	{
	397	Uart2Stat.TcCount++;
	398	#if (USART2_USE_HARDWARE_DE == 1)
	399	#else
	400	Uart2UnsetDE();
	401	#endif
842bb6	402	Uart2Stat.bSendDone = 1;
Q	403	TriggerPendSV();
483170	404	}
Q	405	void Uart2RecvDone()
	406	{
	407	Uart2RecvBuf1DataLen=sizeof(Uart2RecvBuf1) - LL_DMA_GetDataLength(DMA1,LL_DMA_CHANNEL_5);
	408	Uart2Stat.bPacketRecved=1;
	409	Uart2Stat.IdelCount++;
	410	if (Uart2RecvBuf1DataLen>0)
	411	TriggerPendSV();
	412	// ParsePacket((pKBPacket)Uart2RecvBuf1,Uart2RecvBuf1DataLen);
	413	}
	414
	415	int PutStr(char * str1, int len1)
	416	{
	417	// Uart1SendDMA(str1,len1);
	418	PushIn(&Uart1Stat.QTx,str1,len1);
	419	// LL_USART_EnableIT_TXE(USART1);
	420	// LL_USART_EnableIT_TC(USART1);
	421	Uart1TriggerSendDMA();
	422	return len1;
	423	}
	424	int PutStr1(char * str1, int len1)
	425	{
	426	// Uart1SendDMA(str1,len1);
	427	PushIn(&Uart1Stat.QTx,str1,len1);
	428	// LL_USART_EnableIT_TXE(USART1);
	429	// LL_USART_EnableIT_TC(USART1);
	430	Uart1TriggerSendDMA();
5dd1b7	431	Uart1Stat.SentPacket++;
483170	432	return len1;
Q	433	}
	434	int PutStr2(char * str1, int len1)
	435	{
	436	Uart2SendDMA(str1,len1);
	437	// PushIn(&Uart2Stat.QTx,str1,len1);
	438	// LL_USART_EnableIT_TXE(USART1);
	439	// LL_USART_EnableIT_TC(USART1);
	440	// Uart2TriggerSendDMA();
5dd1b7	441	Uart2Stat.SentPacket++;
483170	442	return len1;
Q	443	}
	444
	445	int SendPacket(int nChn, void * pBuf,int len1)
	446	{
	447	if (nChn==1) {
	448	PutStr1((char *)pBuf,len1);
	449	// PushIn(&Uart1Stat.QTx,p1,len1);
	450	// Uart1TriggerSendDMA();
5dd1b7	451
483170	452	}else if (nChn==2){
Q	453	PutStr2((char *)pBuf,len1);
	454	// PushIn(&Uart2Stat.QTx,p1,len1);
	455	// Uart2TriggerSendDMA();
5dd1b7	456
483170	457	}
Q	458	return len1;
	459	}
	460	/*
	461	int SendPacket1(void * pBuf,int len1)
	462	{
	463	PutStr1((char *)pBuf,len1);
	464	// PushIn(&Uart1Stat.QTx,p1,len1);
	465	// Uart1TriggerSendDMA();
	466	Uart1Stat.SentPacket++;
	467	return len1;
	468	}
	469	int SendPacket2(pKBPacket p1,int len1)
	470	{
	471	PutStr2((char *)p1,len1);
	472	// PushIn(&Uart2Stat.QTx,p1,len1);
	473	// Uart2TriggerSendDMA();
	474	Uart2Stat.SentPacket++;
	475	return len1;
	476	}
	477	*/
	478	void ToggleRunLed() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_13);}
	479	void ToggleErrLed() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_14);}
	480	void ToggleErr2Led() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}
	481
	482	#if (BOARD_TYPE == 14)
	483	void ToggleOutStat() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}
	484
	485	void SetOutStat(uchar bOn)
	486	{
	487	if (bOn) {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	488	else {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	489	}
	490	#else
	491	void ToggleOutStat() { LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_11);}
	492
	493	void SetOutStat(uchar bOn)
	494	{
	495	if (bOn) {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_11);}
	496	else {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_11);}
	497	}
	498	#endif
	499
	500	void SetRunLed(uchar bOn)
	501	{
	502	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_13);}
	503	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_13);}
	504	}
	505	void SetErrLed(uchar bOn)
	506	{
	507	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_14);}
	508	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_14);}
	509	}
	510	void SetErr2Led(uchar bOn)
	511	{
	512	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	513	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	514	}
	515	/*
	516	void SetLeds(uchar bRun, uchar bErr)
	517	{
	518	SetRunLed(bRun); SetErrLed (bErr);
	519	}
	520	*/
	521	#define set165SL_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_4)
	522	#define set165SL_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_4)
	523	#define set165CLK_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_5)
	524	#define set165CLK_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_5)
	525	#define Get165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_6)
	526	#define GetCfg165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_7)
	527
	528	unsigned int Input165_8()
	529	{
	530	int x1=0;
	531	__disable_irq();
	532	set165SL_0(); set165SL_1();
	533	unsigned int mask1=0x0080;
	534	volatile uint32_t * p1=&GPIOA->IDR;
	535	for (uint32_t i=8;i;i--)
	536	{
	537	//if (Get165SER()) {}
	538	//else x1\|=mask1;
	539	if (*p1&LL_GPIO_PIN_6) {}
	540	else x1\|=mask1;
	541	//x1<<=1;
	542	//x1\|=!Get165SER();
	543	set165CLK_0();
	544	mask1>>=1;
	545	set165CLK_1();
	546	}
	547	__enable_irq();
	548	return x1;
	549	}
	550
	551	unsigned int Input165(int nBit)
	552	{
	553	int x1=0;
	554	__disable_irq();
	555	set165SL_0(); set165SL_1();
	556	unsigned int mask1=1<<(nBit-1);
	557	volatile uint32_t * p1=&GPIOA->IDR;
	558	for (uint32_t i=nBit;i;i--)
	559	{
	560	//if (Get165SER()) {}
	561	//else x1\|=mask1;
	562	if (*p1&LL_GPIO_PIN_6) {}
	563	else x1\|=mask1;
	564	//x1<<=1;
	565	//x1\|=!Get165SER();
	566	set165CLK_0();
	567	mask1>>=1;
	568	set165CLK_1();
	569	}
	570	__enable_irq();
	571	return x1;
	572	}
	573	unsigned int Input165_R(int nBit)
	574	{
	575	__disable_irq();
	576	set165SL_0(); set165SL_1();
	577	int nBytes = nBit /8;
	578	volatile uint32_t * p1=&GPIOA->IDR;
	579	union stdata
	580	{
	581	int intvalue;
	582	unsigned char Bytes[4];
	583	}rdata;
	584	rdata.intvalue=0;
	585	for (int i=0;i<nBytes;i++)
	586	{
	587	int x1=0;
	588	unsigned int mask1=1<<(7);
	589	for (uint32_t i=8;i;i--)
	590	{
	591	//if (Get165SER()) {}
	592	//else x1\|=mask1;
	593	if (*p1&LL_GPIO_PIN_6) {}
	594	else x1\|=mask1;
	595	//x1<<=1;
	596	//x1\|=!Get165SER();
	597	set165CLK_0();
	598	mask1>>=1;
	599	set165CLK_1();
	600	}
	601	rdata.Bytes[i]=x1;
	602	}
	603	__enable_irq();
	604	return rdata.intvalue;
	605	}
	606
	607	unsigned int Input165Cfg(int nBit)
	608	{
	609	int x1=0;
	610	__disable_irq();
	611	set165SL_0(); set165SL_1();
	612	unsigned int mask1=1<<(nBit-1);
	613	volatile uint32_t * p1=&GPIOA->IDR;
	614	for (uint32_t i=nBit;i;i--)
	615	{
	616	//if (Get165SER()) {}
	617	//else x1\|=mask1;
	618	if (*p1&LL_GPIO_PIN_7) {}
	619	else x1\|=mask1;
	620	//x1<<=1;
	621	//x1\|=!Get165SER();
	622	set165CLK_0();
	623	mask1>>=1;
	624	set165CLK_1();
	625	}
	626	__enable_irq();
	627	return x1;
	628	}
	629
	630	unsigned int GetInput()
	631	{
	632	int BoradType=GetBoardType();
	633	switch (BoradType)
	634	{
	635
	636	case 1:
	637	return Input165(8);
	638	case 2:
	639	return Input165(8);
	640	case 3:
	641	return Input165(16);
	642	case 4:
	643	return Input165(8);
	644	case 5:
	645	case 7:
	646	return Input165(16);
	647	case 6:
	648	case 8:
	649	return Input165(8);
	650	case 9:
	651	return Input165_R(16);
	652	case 10:
	653	return Input165_R(8);
	654	case 11:
	655	return Input165_R(8);
	656	case 13:
	657	return Input165_R(16);
	658	case 14:
5dd1b7	659	return 0; //FPx
483170	660	case 15:
Q	661	return Input165_R(16);
	662	case 16:
	663	return Input165_R(8);
	664
	665	default:
	666	break;
	667	}
	668	return 0;
	669
	670	}
	671	int ReadConfig_0()
	672	{
	673	return 0;
	674	}
	675
	676	int ReadConfig_1()
	677	{
	678	// uchar x = LL_GPIO_ReadInputPort(GPIOB);
	679	// uchar x1 = LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_10);
	680	// uchar x2=(x&0x7) \| (x1 << 3 ) ;
	681	uchar x2=0;
	682	x2=(GPIOB->IDR&0x7) \| ((GPIOB->IDR &0x400)>>7);
	683	x2= (~x2)&0xf;
	684	return x2;
	685	}
	686
	687	int ReadConfig_2()
	688	{
	689	uchar x2=0;
	690	x2=(GPIOB->IDR&0x7) \| ((GPIOB->IDR &0x400)>>7);
	691	x2= (~x2)&0xf;
	692	return x2;
	693	}
	694
	695	int ReadConfig_3()
	696	{
	697	uchar x2=0;
	698	x2 = Input165(24)&0xff;
	699	return x2;
	700
	701	}
	702	int ReadConfig_4()
	703	{
	704
	705	uchar x2=0;
	706	x2 = Input165(16)&0xff;
	707	return x2;
	708	}
	709
	710	int ReadConfig_5()
	711	{
	712	uchar x2=0;
	713	x2 = Input165Cfg(8)&0xff;
	714	return x2;
	715	}
	716
	717	int ReadConfig_11()
	718	{
	719	uchar x2=0;
	720	x2=((GPIOB->IDR&0x2)<<2);
	721	x2= ((~x2)&0x8)\|1;
	722	return x2;
	723	}
	724
	725	int ReadJumperSW()
	726	{
	727	int BoradType=GetBoardType();
	728	switch (BoradType)
	729	{
	730	case 0:
	731	return ReadConfig_0();
	732	case 1:
	733	return ReadConfig_1(); //old board 4 in 4 o
	734	case 2:
	735	return ReadConfig_2(); //old board 8 in 8 o
	736	case 3:
	737	return ReadConfig_3(); //Master 16 in16 o
	738	case 4:
	739	return ReadConfig_4(); //Slave 8 in 8 o
	740	case 5:
	741	case 7:
	742	return ReadConfig_5(); // New Master 16 in16 o
	743	case 6:
	744	case 8:
	745	return ReadConfig_5(); //New Slave 8 in 8 o
	746	case 9:
	747	case 10:
	748	return ReadConfig_5(); //New Master Slave 8 in 8 o
	749	case 11:
	750	return ReadConfig_11(); //Mini Board
	751	case 13:
	752	return ReadConfig_5();
	753	case 14:
5dd1b7	754	return (~(LL_GPIO_ReadInputPort(GPIOA)>>4))&0x0f; //FPx
483170	755	case 15:
Q	756	case 16:
	757	return ReadConfig_5(); //Wireless Master Slave 8 in 8 o
	758	default:
	759
	760	return 0;
	761	}
	762	}
	763
	764	#define SRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_13)
	765	#define SRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_13)
	766	#define STRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_12)
	767	#define STRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_12)
	768	#define SER2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_15)
	769	#define SER2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_15)
	770
	771	void Enable595(uchar bEnable)
	772	{
	773	if (bEnable) {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_8);}
	774	else {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_8);}
	775	}
	776
	777	void Output595_8(unsigned int cc)
	778	{
	779	//unsigned char i;
	780	;// 74HC595输出程序，输出8位
	781	// cc=~0x3f;
	782	__disable_irq();
	783	STRCLK2_1();
	784	unsigned int mask1=0x0080;
	785	//volatile uint32_t * p1 = &GPIOB->BRR;
	786	//volatile uint32_t * p2 = &GPIOB->BSRR;
	787	for (;mask1;)
	788	{
	789	SRCLK2_0();
	790	//*p1=LL_GPIO_PIN_13;
	791	if (cc&mask1) {SER2_1();}
	792	else {SER2_0();}
	793	mask1>>=1;
	794	SRCLK2_1();
	795	// __nop();
	796	//*p2=LL_GPIO_PIN_13;
	797	}
	798	STRCLK2_0();
	799	STRCLK2_1();
	800	__enable_irq();
	801	}
	802
	803	void Output595_16(unsigned int cc)
	804	{
	805	//unsigned char i;
	806	;// 74HC595输出程序，输出16位
	807	// cc=~0x3f;
	808	__disable_irq();
	809	STRCLK2_1();
	810	unsigned int mask1=0x8000;
	811	//volatile uint32_t * p1 = &GPIOB->BRR;
	812	//volatile uint32_t * p2 = &GPIOB->BSRR;
	813	for (;mask1;)
	814	{
	815	SRCLK2_0();
	816	//*p1=LL_GPIO_PIN_13;
	817	if (cc&mask1) {SER2_1();}
	818	else {SER2_0();}
	819	mask1>>=1;
	820	SRCLK2_1();
	821	// __nop();
	822	//*p2=LL_GPIO_PIN_13;
	823	}
	824	STRCLK2_0();
	825	STRCLK2_1();
	826	__enable_irq();
	827	}
	828
	829	/*
	830	#define STRCLK12_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_7)
	831	#define STRCLK12_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_7)
	832
	833	void PutOutputSPI1(unsigned int Y)
	834	{
	835	__disable_irq();
	836	STRCLK12_1();
	837	LL_SPI_TransmitData8(SPI1,Y>>8);
	838	int i=0;
	839	while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
	840	{
	841	}
	842	KMem.SDD[28]=i;
	843	i=0;
	844	while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
	845	{
	846	i++;
	847	}
	848	LL_SPI_TransmitData8(SPI1,Y);
	849	while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
	850	{
	851	}
	852	KMem.SDD[28]=i;
	853	i=0;
	854	while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
	855	{
	856	i++;
	857	}
	858	KMem.SDD[30]=i;
	859	STRCLK12_0();
	860	__nop();
	861	STRCLK12_1();
	862	__enable_irq();
	863	}
	864	*/
	865
	866	void PutOutputSPI2(unsigned int Y)
	867	{
	868	__disable_irq();
	869	STRCLK2_1();
	870	LL_SPI_TransmitData8(SPI2,Y>>8);
	871	int i=0;
	872	while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
	873	{
	874	}
	875	KMem.SDD[28]=i;
	876	i=0;
	877	while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
	878	{
	879	i++;
	880	}
	881	LL_SPI_TransmitData8(SPI2,Y);
	882	while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
	883	{
	884	}
	885	KMem.SDD[28]=i;
	886	i=0;
	887	while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
	888	{
	889	i++;
	890	}
	891	KMem.SDD[30]=i;
	892	STRCLK2_0();
	893	STRCLK2_1();
	894	__enable_irq();
	895	}
	896
	897	void PutOutput(unsigned int Y)
	898	{
	899	#if (BOARD_TYPE == 14)
	900	return ;
	901	#else
	902	PutOutputSPI2(Y);
	903	//Output595_16(Y);
	904	#endif
	905	}
	906
	907	#if (BOARD_TYPE == 9 \|\| BOARD_TYPE == 10 \|\| BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	908	//#pragma message("9,10")
	909	// V4.2 管脚排列向右移动了一位。
	910	#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
	911	#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
	912	#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
	913	#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
	914	#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
	915	#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
	916	#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_11)
	917	#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_11)
	918	#else //按照原来的管脚排列
	919	#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_0)
	920	#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_0)
	921	#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
	922	#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
	923	#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
	924	#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
	925	#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
	926	#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
	927	#endif
	928
	929
	930	void EnableDisIn(uchar bEnable)
	931	{
	932	if (bEnable) {OE1_0();}
	933	else {OE1_1();}
	934	}
	935
	936	void displayInput(unsigned int cc)
	937	{
	938	//unsigned char i;
	939	;// 74HC595输出程序，输出8位
	940	// cc=~0x3f;
	941	__disable_irq();
	942	STRCLK1_1();
	943	unsigned int mask1=0x8000;
	944	//volatile uint32_t * p1 = &GPIOB->BRR;
	945	//volatile uint32_t * p2 = &GPIOB->BSRR;`````
	946	for (;mask1;)
	947	{
	948	SRCLK1_0();
	949	//*p1=LL_GPIO_PIN_13;
	950	if (cc&mask1) {SER1_1();}
	951	else {SER1_0();}
	952	mask1>>=1;
	953	SRCLK1_1();
	954	// __nop();
	955	//*p2=LL_GPIO_PIN_13;
	956	}
	957	STRCLK1_0();
	958	STRCLK1_1();
	959	__enable_irq();
	960	}