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