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