F030C8T6_Kbus_MIX.git

QuakeGod

2024-08-06 7d8ba5df7d883c86c24aa38449c4a6dd126e920f

提交 \| 用户 \| 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	};
7d8ba5	195	/*
483170	196	uint16_t crc16table(const uint8_t *ptr, uint16_t len)
Q	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	}
7d8ba5	209	*/
Q	210	const uint16_t crctalbeabs[] = {
	211	0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401,
	212	0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400
	213	};
	214
	215	uint16_t crc16tablefast(const uint8_t *ptr, uint16_t len)
	216	{
	217	uint16_t crc = 0xffff;
	218	uint16_t i;
	219	uint8_t ch;
	220
	221	for (i = 0; i < len; i++) {
	222	ch = *ptr++;
	223	crc = crctalbeabs[(ch ^ crc) & 15] ^ (crc >> 4);
	224	crc = crctalbeabs[((ch >> 4) ^ crc) & 15] ^ (crc >> 4);
	225	}
	226
	227	return crc;
	228	}
	229
842bb6	230	/*
483170	231	void modbuscrc16test()
Q	232	{
	233	printf("\n");
	234	printf(" Modbus CRC16 tester\n");
	235	printf("-----------------------------------------------------------------------\n");
	236	uint8_t crc16_data[] = { 0x01, 0x04, 0x04, 0x43, 0x6b, 0x58, 0x0e }; // expected crc value 0xD825.
	237	printf(" modbus crc16table test, expected value : 0xd825, calculate value : 0x%x\n", crc16table(crc16_data, sizeof(crc16_data)));
	238	// printf(" modbus crc16tablefast test, expected value : 0xd825, calculate value : 0x%x\n", crc16tablefast(crc16_data, sizeof(crc16_data)));
	239	printf(" modbus crc16bitbybit test, expected value : 0xd825, calculate value : 0x%x\n", crc16bitbybit(crc16_data, sizeof(crc16_data)));
	240	}
842bb6	241	*/
483170	242	int InitUartstat(stUartStat * pUartstat,void * pBufRx, int nSizeRx, void * pBufTx, int nSizeTx)
Q	243	{
	244	memset(pUartstat,sizeof(stUartStat),0);
842bb6	245	if (pBufRx) initQueue(&pUartstat->QRx,pBufRx,nSizeRx);
Q	246	if (pBufTx) initQueue(&pUartstat->QTx,pBufTx,nSizeTx);
483170	247	return 0;
Q	248	}
	249
	250	int Uart1SendDMA(void * pData, int nSize)
	251	{
	252	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_2);
	253	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_2, (uint32_t)pData,
	254	(uint32_t)&USART1->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
	255	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_2,nSize);
	256	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_2);
	257	Uart1Stat.DMASendLen=nSize;
	258	Uart1Stat.bSending=1;
	259	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_2);
	260	LL_USART_EnableDMAReq_TX(USART1);
	261	return nSize;
	262	}
	263
	264	int Uart1TriggerSendDMA()
	265	{
	266	if (!Uart1Stat.bSending&&!IsEmpty(&Uart1Stat.QTx))
	267	{
	268	int len1=GetContinueData(&Uart1Stat.QTx);
	269	Uart1SendDMA(GetReadBuffer(&Uart1Stat.QTx),len1);
	270	}
	271	return 0;
	272	}
	273
	274	void Uart2SetDE(void)
	275	{
	276	LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_1);
	277	}
	278	void Uart2UnsetDE(void)
	279	{
	280	LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_1);
	281	}
	282	void DelayUs(int nUs)
	283	{
	284	for (int i=0;i<nUs;i++)
	285	for (volatile int j=0;j<24;j++)
	286	{
	287	__nop();
	288	}
	289	}
	290
	291	int Uart2RecvDMA(void * pBuf, int nSize)
	292	{
	293	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_5);
	294	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_5, (uint32_t)&USART2->RDR,
	295	(uint32_t)pBuf, LL_DMA_DIRECTION_PERIPH_TO_MEMORY);
	296	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_5,nSize);
	297	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_5);
	298	Uart2Stat.DMARecvLen=nSize;
	299	Uart2Stat.bRecving=1;
	300	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_5);
	301	LL_USART_EnableDMAReq_RX(USART2);
	302	return 0;
	303	}
	304	int Uart2SendDMA(void * pData, int nSize)
	305	{
	306	#if (USART2_USE_HARDWARE_DE == 1)
	307
	308	#else
	309	Uart2SetDE();
	310	DelayUs(USART2_DE_ASSERTION_TIME);
	311	#endif
	312	LL_DMA_DisableChannel(DMA1,LL_DMA_CHANNEL_4);
	313	LL_DMA_ConfigAddresses(DMA1,LL_DMA_CHANNEL_4, (uint32_t)pData,
	314	(uint32_t)&USART2->TDR, LL_DMA_DIRECTION_MEMORY_TO_PERIPH);
	315	LL_DMA_SetDataLength(DMA1,LL_DMA_CHANNEL_4,nSize);
	316	LL_DMA_EnableChannel(DMA1,LL_DMA_CHANNEL_4);
	317	Uart2Stat.DMASendLen=nSize;
	318	Uart2Stat.bSending=1;
	319	LL_DMA_EnableIT_TC(DMA1,LL_DMA_CHANNEL_4);
	320	LL_USART_EnableDMAReq_TX(USART2);
	321	return nSize;
	322	}
	323	int Uart2TriggerSendDMA()
	324	{
	325	if (!Uart2Stat.bSending&&!IsEmpty(&Uart2Stat.QTx))
	326	{
	327	int len1=GetContinueData(&Uart2Stat.QTx);
	328	Uart2SendDMA(GetReadBuffer(&Uart2Stat.QTx),len1);
	329	}
	330	return 0;
	331	}
	332
	333	void TriggerPendSV()
	334	{
	335	SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	336	}
	337
	338	void SPI1_IRQ_CallBack()
	339	{
	340	uint8_t value;
	341	// LL_GPIO_TogglePin(GPIOB,LL_GPIO_PIN_7);
	342	if (LL_SPI_IsActiveFlag_RXNE(SPI1))
	343	{
	344	value = LL_SPI_ReceiveData8( SPI1);
	345	#if (BOARD_TYPE == 14)
	346	KMem.WDD[62]++;
	347	KMem.WDT[122]++;
	348	if (!bSPI1Sending)
	349	{
	350	logData(value);
	351	}
	352	if (!bSPI1Sending && (1 \|\| bSPI1Recving))
	353	{
	354	SPI1RecvBuf[nSPI1RecvPos]=value;
	355	nSPI1RecvPos++;
	356
	357	if (value==0x0d)
	358	{
	359	logData(nSPI1RecvPos);
	360
	361	nSPI1RecvLenInBuf=nSPI1RecvPos;
	362	bSPI1RecvDone=1;
	363	nSPI1RecvPos=0;
	364	bSPI1Recving=0;
	365
	366
	367	TriggerPendSV();
	368	}
	369	}
	370	if (bSPI1Sending)
	371	{
	372	nSPI1SentLen++;
	373	KMem.SDD[63]++;
	374
	375	if (nSPI1SentLen >= nSPI1ToSendLen) {
	376	SetACKPin_1();
	377	bSPI1Sending=0;
	378	bSPI1SendDone=1;
	379	bSPI1Recving=1;
	380	nSPI1RecvPos=0;
5dd1b7	381	SetFPxDEPin_0();
483170	382	}
Q	383	else {
	384	value = SPI1SendBuf[nSPI1SentLen];
	385	LL_SPI_TransmitData8(SPI1,value);
	386	logData(value);
	387	}
	388	}
842bb6	389	#else
Q	390	UNUSED(value);
	391	#endif
483170	392	}
Q	393	}
	394
	395	void Uart1SendDone()
	396	{
	397	Uart1Stat.TcCount++;
	398	return;
	399	}
	400
	401	void Uart1RecvDone()
	402	{
	403	Uart1Stat.IdelCount++;
	404	// NVIC_SetPendingIRQ(PendSV_IRQn);
	405	// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	406
	407	if (Uart1RecvBuf1DataLen >0)
	408	{
	409	Uart1Stat.bPacketRecved=1;
	410	// SCB->ICSR=SCB_ICSR_PENDSVSET_Msk; //1<<SCB_ICSR_PENDSVSET_Pos;
	411	// KLParsePacket(Uart1RecvBuf1,Uart1RecvBuf1DataLen);
	412	// Uart1RecvBuf1DataLen=0;
7d8ba5	413	TriggerPendSV();
483170	414	}
Q	415	}
	416
	417	void Uart2SendDone()
	418	{
	419	Uart2Stat.TcCount++;
	420	#if (USART2_USE_HARDWARE_DE == 1)
	421	#else
	422	Uart2UnsetDE();
	423	#endif
842bb6	424	Uart2Stat.bSendDone = 1;
Q	425	TriggerPendSV();
483170	426	}
Q	427	void Uart2RecvDone()
	428	{
	429	Uart2RecvBuf1DataLen=sizeof(Uart2RecvBuf1) - LL_DMA_GetDataLength(DMA1,LL_DMA_CHANNEL_5);
	430	Uart2Stat.bPacketRecved=1;
	431	Uart2Stat.IdelCount++;
	432	if (Uart2RecvBuf1DataLen>0)
	433	TriggerPendSV();
	434	// ParsePacket((pKBPacket)Uart2RecvBuf1,Uart2RecvBuf1DataLen);
	435	}
	436
	437	int PutStr(char * str1, int len1)
	438	{
	439	// Uart1SendDMA(str1,len1);
	440	PushIn(&Uart1Stat.QTx,str1,len1);
	441	// LL_USART_EnableIT_TXE(USART1);
	442	// LL_USART_EnableIT_TC(USART1);
	443	Uart1TriggerSendDMA();
	444	return len1;
	445	}
	446	int PutStr1(char * str1, int len1)
	447	{
	448	// Uart1SendDMA(str1,len1);
	449	PushIn(&Uart1Stat.QTx,str1,len1);
	450	// LL_USART_EnableIT_TXE(USART1);
	451	// LL_USART_EnableIT_TC(USART1);
	452	Uart1TriggerSendDMA();
5dd1b7	453	Uart1Stat.SentPacket++;
483170	454	return len1;
Q	455	}
	456	int PutStr2(char * str1, int len1)
	457	{
	458	Uart2SendDMA(str1,len1);
	459	// PushIn(&Uart2Stat.QTx,str1,len1);
	460	// LL_USART_EnableIT_TXE(USART1);
	461	// LL_USART_EnableIT_TC(USART1);
	462	// Uart2TriggerSendDMA();
5dd1b7	463	Uart2Stat.SentPacket++;
483170	464	return len1;
Q	465	}
	466
	467	int SendPacket(int nChn, void * pBuf,int len1)
	468	{
	469	if (nChn==1) {
	470	PutStr1((char *)pBuf,len1);
	471	// PushIn(&Uart1Stat.QTx,p1,len1);
	472	// Uart1TriggerSendDMA();
5dd1b7	473
483170	474	}else if (nChn==2){
Q	475	PutStr2((char *)pBuf,len1);
	476	// PushIn(&Uart2Stat.QTx,p1,len1);
	477	// Uart2TriggerSendDMA();
5dd1b7	478
483170	479	}
Q	480	return len1;
	481	}
	482	/*
	483	int SendPacket1(void * pBuf,int len1)
	484	{
	485	PutStr1((char *)pBuf,len1);
	486	// PushIn(&Uart1Stat.QTx,p1,len1);
	487	// Uart1TriggerSendDMA();
	488	Uart1Stat.SentPacket++;
	489	return len1;
	490	}
	491	int SendPacket2(pKBPacket p1,int len1)
	492	{
	493	PutStr2((char *)p1,len1);
	494	// PushIn(&Uart2Stat.QTx,p1,len1);
	495	// Uart2TriggerSendDMA();
	496	Uart2Stat.SentPacket++;
	497	return len1;
	498	}
	499	*/
	500	void ToggleRunLed() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_13);}
	501	void ToggleErrLed() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_14);}
	502	void ToggleErr2Led() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}
	503
	504	#if (BOARD_TYPE == 14)
	505	void ToggleOutStat() { LL_GPIO_TogglePin(GPIOC,LL_GPIO_PIN_15);}
	506
	507	void SetOutStat(uchar bOn)
	508	{
	509	if (bOn) {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	510	else {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	511	}
	512	#else
	513	void ToggleOutStat() { LL_GPIO_TogglePin(GPIOA,LL_GPIO_PIN_11);}
	514
	515	void SetOutStat(uchar bOn)
	516	{
	517	if (bOn) {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_11);}
	518	else {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_11);}
	519	}
	520	#endif
	521
	522	void SetRunLed(uchar bOn)
	523	{
	524	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_13);}
	525	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_13);}
	526	}
	527	void SetErrLed(uchar bOn)
	528	{
	529	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_14);}
	530	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_14);}
	531	}
	532	void SetErr2Led(uchar bOn)
	533	{
	534	if (bOn) {LL_GPIO_ResetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	535	else {LL_GPIO_SetOutputPin(GPIOC,LL_GPIO_PIN_15);}
	536	}
	537	/*
	538	void SetLeds(uchar bRun, uchar bErr)
	539	{
	540	SetRunLed(bRun); SetErrLed (bErr);
	541	}
	542	*/
	543	#define set165SL_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_4)
	544	#define set165SL_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_4)
	545	#define set165CLK_0() LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_5)
	546	#define set165CLK_1() LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_5)
	547	#define Get165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_6)
	548	#define GetCfg165SER() LL_GPIO_IsInputPinSet(GPIOA,LL_GPIO_PIN_7)
	549
	550	unsigned int Input165_8()
	551	{
	552	int x1=0;
	553	__disable_irq();
	554	set165SL_0(); set165SL_1();
	555	unsigned int mask1=0x0080;
	556	volatile uint32_t * p1=&GPIOA->IDR;
	557	for (uint32_t i=8;i;i--)
	558	{
	559	//if (Get165SER()) {}
	560	//else x1\|=mask1;
	561	if (*p1&LL_GPIO_PIN_6) {}
	562	else x1\|=mask1;
	563	//x1<<=1;
	564	//x1\|=!Get165SER();
	565	set165CLK_0();
	566	mask1>>=1;
	567	set165CLK_1();
	568	}
	569	__enable_irq();
	570	return x1;
	571	}
	572
	573	unsigned int Input165(int nBit)
	574	{
	575	int x1=0;
	576	__disable_irq();
	577	set165SL_0(); set165SL_1();
	578	unsigned int mask1=1<<(nBit-1);
	579	volatile uint32_t * p1=&GPIOA->IDR;
	580	for (uint32_t i=nBit;i;i--)
	581	{
	582	//if (Get165SER()) {}
	583	//else x1\|=mask1;
	584	if (*p1&LL_GPIO_PIN_6) {}
	585	else x1\|=mask1;
	586	//x1<<=1;
	587	//x1\|=!Get165SER();
	588	set165CLK_0();
	589	mask1>>=1;
	590	set165CLK_1();
	591	}
	592	__enable_irq();
	593	return x1;
	594	}
	595	unsigned int Input165_R(int nBit)
	596	{
	597	__disable_irq();
	598	set165SL_0(); set165SL_1();
	599	int nBytes = nBit /8;
	600	volatile uint32_t * p1=&GPIOA->IDR;
	601	union stdata
	602	{
	603	int intvalue;
	604	unsigned char Bytes[4];
	605	}rdata;
	606	rdata.intvalue=0;
	607	for (int i=0;i<nBytes;i++)
	608	{
	609	int x1=0;
	610	unsigned int mask1=1<<(7);
	611	for (uint32_t i=8;i;i--)
	612	{
	613	//if (Get165SER()) {}
	614	//else x1\|=mask1;
	615	if (*p1&LL_GPIO_PIN_6) {}
	616	else x1\|=mask1;
	617	//x1<<=1;
	618	//x1\|=!Get165SER();
	619	set165CLK_0();
	620	mask1>>=1;
	621	set165CLK_1();
	622	}
	623	rdata.Bytes[i]=x1;
	624	}
	625	__enable_irq();
	626	return rdata.intvalue;
	627	}
	628
	629	unsigned int Input165Cfg(int nBit)
	630	{
	631	int x1=0;
	632	__disable_irq();
	633	set165SL_0(); set165SL_1();
	634	unsigned int mask1=1<<(nBit-1);
	635	volatile uint32_t * p1=&GPIOA->IDR;
	636	for (uint32_t i=nBit;i;i--)
	637	{
	638	//if (Get165SER()) {}
	639	//else x1\|=mask1;
	640	if (*p1&LL_GPIO_PIN_7) {}
	641	else x1\|=mask1;
	642	//x1<<=1;
	643	//x1\|=!Get165SER();
	644	set165CLK_0();
	645	mask1>>=1;
	646	set165CLK_1();
	647	}
	648	__enable_irq();
	649	return x1;
	650	}
	651
	652	unsigned int GetInput()
	653	{
	654	int BoradType=GetBoardType();
	655	switch (BoradType)
	656	{
	657
	658	case 1:
	659	return Input165(8);
	660	case 2:
	661	return Input165(8);
	662	case 3:
	663	return Input165(16);
	664	case 4:
	665	return Input165(8);
	666	case 5:
	667	case 7:
	668	return Input165(16);
	669	case 6:
	670	case 8:
	671	return Input165(8);
	672	case 9:
	673	return Input165_R(16);
	674	case 10:
	675	return Input165_R(8);
	676	case 11:
	677	return Input165_R(8);
	678	case 13:
	679	return Input165_R(16);
	680	case 14:
5dd1b7	681	return 0; //FPx
483170	682	case 15:
Q	683	return Input165_R(16);
	684	case 16:
	685	return Input165_R(8);
	686
	687	default:
	688	break;
	689	}
	690	return 0;
	691
	692	}
	693	int ReadConfig_0()
	694	{
	695	return 0;
	696	}
	697
	698	int ReadConfig_1()
	699	{
	700	// uchar x = LL_GPIO_ReadInputPort(GPIOB);
	701	// uchar x1 = LL_GPIO_IsInputPinSet(GPIOB,LL_GPIO_PIN_10);
	702	// uchar x2=(x&0x7) \| (x1 << 3 ) ;
	703	uchar x2=0;
	704	x2=(GPIOB->IDR&0x7) \| ((GPIOB->IDR &0x400)>>7);
	705	x2= (~x2)&0xf;
	706	return x2;
	707	}
	708
	709	int ReadConfig_2()
	710	{
	711	uchar x2=0;
	712	x2=(GPIOB->IDR&0x7) \| ((GPIOB->IDR &0x400)>>7);
	713	x2= (~x2)&0xf;
	714	return x2;
	715	}
	716
	717	int ReadConfig_3()
	718	{
	719	uchar x2=0;
	720	x2 = Input165(24)&0xff;
	721	return x2;
	722
	723	}
	724	int ReadConfig_4()
	725	{
	726
	727	uchar x2=0;
	728	x2 = Input165(16)&0xff;
	729	return x2;
	730	}
	731
	732	int ReadConfig_5()
	733	{
	734	uchar x2=0;
	735	x2 = Input165Cfg(8)&0xff;
	736	return x2;
	737	}
	738
	739	int ReadConfig_11()
	740	{
	741	uchar x2=0;
	742	x2=((GPIOB->IDR&0x2)<<2);
	743	x2= ((~x2)&0x8)\|1;
	744	return x2;
	745	}
	746
	747	int ReadJumperSW()
	748	{
	749	int BoradType=GetBoardType();
	750	switch (BoradType)
	751	{
	752	case 0:
	753	return ReadConfig_0();
	754	case 1:
	755	return ReadConfig_1(); //old board 4 in 4 o
	756	case 2:
	757	return ReadConfig_2(); //old board 8 in 8 o
	758	case 3:
	759	return ReadConfig_3(); //Master 16 in16 o
	760	case 4:
	761	return ReadConfig_4(); //Slave 8 in 8 o
	762	case 5:
	763	case 7:
	764	return ReadConfig_5(); // New Master 16 in16 o
	765	case 6:
	766	case 8:
	767	return ReadConfig_5(); //New Slave 8 in 8 o
	768	case 9:
	769	case 10:
	770	return ReadConfig_5(); //New Master Slave 8 in 8 o
	771	case 11:
	772	return ReadConfig_11(); //Mini Board
	773	case 13:
	774	return ReadConfig_5();
	775	case 14:
5dd1b7	776	return (~(LL_GPIO_ReadInputPort(GPIOA)>>4))&0x0f; //FPx
483170	777	case 15:
Q	778	case 16:
	779	return ReadConfig_5(); //Wireless Master Slave 8 in 8 o
	780	default:
	781
	782	return 0;
	783	}
	784	}
	785
	786	#define SRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_13)
	787	#define SRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_13)
	788	#define STRCLK2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_12)
	789	#define STRCLK2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_12)
	790	#define SER2_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_15)
	791	#define SER2_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_15)
	792
	793	void Enable595(uchar bEnable)
	794	{
	795	if (bEnable) {LL_GPIO_ResetOutputPin(GPIOA,LL_GPIO_PIN_8);}
	796	else {LL_GPIO_SetOutputPin(GPIOA,LL_GPIO_PIN_8);}
	797	}
	798
	799	void Output595_8(unsigned int cc)
	800	{
	801	//unsigned char i;
	802	;// 74HC595输出程序，输出8位
	803	// cc=~0x3f;
	804	__disable_irq();
	805	STRCLK2_1();
	806	unsigned int mask1=0x0080;
	807	//volatile uint32_t * p1 = &GPIOB->BRR;
	808	//volatile uint32_t * p2 = &GPIOB->BSRR;
	809	for (;mask1;)
	810	{
	811	SRCLK2_0();
	812	//*p1=LL_GPIO_PIN_13;
	813	if (cc&mask1) {SER2_1();}
	814	else {SER2_0();}
	815	mask1>>=1;
	816	SRCLK2_1();
	817	// __nop();
	818	//*p2=LL_GPIO_PIN_13;
	819	}
	820	STRCLK2_0();
	821	STRCLK2_1();
	822	__enable_irq();
	823	}
	824
	825	void Output595_16(unsigned int cc)
	826	{
	827	//unsigned char i;
	828	;// 74HC595输出程序，输出16位
	829	// cc=~0x3f;
	830	__disable_irq();
	831	STRCLK2_1();
	832	unsigned int mask1=0x8000;
	833	//volatile uint32_t * p1 = &GPIOB->BRR;
	834	//volatile uint32_t * p2 = &GPIOB->BSRR;
	835	for (;mask1;)
	836	{
	837	SRCLK2_0();
	838	//*p1=LL_GPIO_PIN_13;
	839	if (cc&mask1) {SER2_1();}
	840	else {SER2_0();}
	841	mask1>>=1;
	842	SRCLK2_1();
	843	// __nop();
	844	//*p2=LL_GPIO_PIN_13;
	845	}
	846	STRCLK2_0();
	847	STRCLK2_1();
	848	__enable_irq();
	849	}
	850
	851	/*
	852	#define STRCLK12_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_7)
	853	#define STRCLK12_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_7)
	854
	855	void PutOutputSPI1(unsigned int Y)
	856	{
	857	__disable_irq();
	858	STRCLK12_1();
	859	LL_SPI_TransmitData8(SPI1,Y>>8);
	860	int i=0;
	861	while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
	862	{
	863	}
	864	KMem.SDD[28]=i;
	865	i=0;
	866	while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
	867	{
	868	i++;
	869	}
	870	LL_SPI_TransmitData8(SPI1,Y);
	871	while (LL_SPI_IsActiveFlag_TXE(SPI1) == RESET)
	872	{
	873	}
	874	KMem.SDD[28]=i;
	875	i=0;
	876	while (LL_SPI_IsActiveFlag_BSY(SPI1) == SET)
	877	{
	878	i++;
	879	}
	880	KMem.SDD[30]=i;
	881	STRCLK12_0();
	882	__nop();
	883	STRCLK12_1();
	884	__enable_irq();
	885	}
	886	*/
	887
	888	void PutOutputSPI2(unsigned int Y)
	889	{
	890	__disable_irq();
	891	STRCLK2_1();
	892	LL_SPI_TransmitData8(SPI2,Y>>8);
	893	int i=0;
	894	while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
	895	{
	896	}
	897	KMem.SDD[28]=i;
	898	i=0;
	899	while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
	900	{
	901	i++;
	902	}
	903	LL_SPI_TransmitData8(SPI2,Y);
	904	while (LL_SPI_IsActiveFlag_TXE(SPI2) == RESET)
	905	{
	906	}
	907	KMem.SDD[28]=i;
	908	i=0;
	909	while (LL_SPI_IsActiveFlag_BSY(SPI2) == SET)
	910	{
	911	i++;
	912	}
	913	KMem.SDD[30]=i;
	914	STRCLK2_0();
	915	STRCLK2_1();
	916	__enable_irq();
	917	}
	918
	919	void PutOutput(unsigned int Y)
	920	{
	921	#if (BOARD_TYPE == 14)
	922	return ;
	923	#else
	924	PutOutputSPI2(Y);
	925	//Output595_16(Y);
	926	#endif
	927	}
	928
	929	#if (BOARD_TYPE == 9 \|\| BOARD_TYPE == 10 \|\| BOARD_TYPE == 15 \|\| BOARD_TYPE == 16)
	930	//#pragma message("9,10")
	931	// V4.2 管脚排列向右移动了一位。
	932	#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
	933	#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
	934	#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
	935	#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
	936	#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
	937	#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
	938	#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_11)
	939	#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_11)
	940	#else //按照原来的管脚排列
	941	#define SRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_0)
	942	#define SRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_0)
	943	#define STRCLK1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_1)
	944	#define STRCLK1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_1)
	945	#define OE1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_2)
	946	#define OE1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_2)
	947	#define SER1_0() LL_GPIO_ResetOutputPin(GPIOB,LL_GPIO_PIN_10)
	948	#define SER1_1() LL_GPIO_SetOutputPin(GPIOB,LL_GPIO_PIN_10)
	949	#endif
	950
	951
	952	void EnableDisIn(uchar bEnable)
	953	{
	954	if (bEnable) {OE1_0();}
	955	else {OE1_1();}
	956	}
	957
	958	void displayInput(unsigned int cc)
	959	{
	960	//unsigned char i;
	961	;// 74HC595输出程序，输出8位
	962	// cc=~0x3f;
	963	__disable_irq();
	964	STRCLK1_1();
	965	unsigned int mask1=0x8000;
	966	//volatile uint32_t * p1 = &GPIOB->BRR;
	967	//volatile uint32_t * p2 = &GPIOB->BSRR;`````
	968	for (;mask1;)
	969	{
	970	SRCLK1_0();
	971	//*p1=LL_GPIO_PIN_13;
	972	if (cc&mask1) {SER1_1();}
	973	else {SER1_0();}
	974	mask1>>=1;
	975	SRCLK1_1();
	976	// __nop();
	977	//*p2=LL_GPIO_PIN_13;
	978	}
	979	STRCLK1_0();
	980	STRCLK1_1();
	981	__enable_irq();
	982	}