STM32基础工程生成
首先使用STM32CUBEMX生成STM32的基础工程，配置时钟到72M主频：



配置SPI前，首先查看WK2124的芯片手册，手册里面说明了WK2124的SPI最高支持到10M并且使用SPI模式0，SPI的模式0就是时钟空闲电平为低电平且在第一个时钟延采样：



所以STM32CUBEMX需要这样配置：



IO配置：
WK2124的硬件复位引脚，这个引脚最好接上，使用STM32的IO进行控制
WK2124的片选引脚
如果用WK2124的中断，那么还需要配置一个IO为外部中断
WK2124驱动代码
代码已经测试通过无问题，贴一下：

头文件

1. /*
   
2. * wk2xxx.h
   
3. *
   
4. *  Created on: Jun 17, 2021
   
5. *      Author: hello
   
6. */
   
7. 
   
8. #ifndef SRC_WK2XXX_H_
   
9. #define SRC_WK2XXX_H_
   
10. 
    
11. #include "main.h"
    
12. 
    
13. 
    
14. #define         WK2XXX_GENA     0X00
    
15. #define         WK2XXX_GRST     0X01
    
16. #define                WK2XXX_GMUT     0X02
    
17. #define         WK2XXX_GIER     0X10
    
18. #define         WK2XXX_GIFR     0X11
    
19. #define         WK2XXX_GPDIR    0X21
    
20. #define         WK2XXX_GPDAT    0X31
    
21. //wkxxxx  slave uarts  rigister address defines
    
22. 
    
23. #define         WK2XXX_SPAGE    0X03
    
24. //PAGE0
    
25. #define         WK2XXX_SCR      0X04
    
26. #define         WK2XXX_LCR      0X05
    
27. #define         WK2XXX_FCR      0X06
    
28. #define         WK2XXX_SIER     0X07
    
29. #define         WK2XXX_SIFR     0X08
    
30. #define         WK2XXX_TFCNT    0X09
    
31. #define         WK2XXX_RFCNT    0X0A
    
32. #define         WK2XXX_FSR      0X0B
    
33. #define         WK2XXX_LSR      0X0C
    
34. #define         WK2XXX_FDAT     0X0D
    
35. #define         WK2XXX_FWCR     0X0E
    
36. #define         WK2XXX_RS485    0X0F
    
37. //PAGE1
    
38. #define         WK2XXX_BAUD1    0X04
    
39. #define         WK2XXX_BAUD0    0X05
    
40. #define         WK2XXX_PRES     0X06
    
41. #define         WK2XXX_RFTL     0X07
    
42. #define         WK2XXX_TFTL     0X08
    
43. #define         WK2XXX_FWTH     0X09
    
44. #define         WK2XXX_FWTL     0X0A
    
45. #define         WK2XXX_XON1     0X0B
    
46. #define         WK2XXX_XOFF1    0X0C
    
47. #define         WK2XXX_SADR     0X0D
    
48. #define         WK2XXX_SAEN     0X0E
    
49. #define         WK2XXX_RTSDLY   0X0F
    
50. 
    
51. //WK串口扩展芯片的寄存器的位定义
    
52. //wkxxx register bit defines
    
53. // GENA
    
54. #define         WK2XXX_UT4EN        0x08
    
55. #define         WK2XXX_UT3EN        0x04
    
56. #define         WK2XXX_UT2EN        0x02
    
57. #define         WK2XXX_UT1EN        0x01
    
58. //GRST
    
59. #define         WK2XXX_UT4SLEEP        0x80
    
60. #define         WK2XXX_UT3SLEEP        0x40
    
61. #define         WK2XXX_UT2SLEEP        0x20
    
62. #define         WK2XXX_UT1SLEEP        0x10
    
63. #define         WK2XXX_UT4RST        0x08
    
64. #define         WK2XXX_UT3RST        0x04
    
65. #define         WK2XXX_UT2RST        0x02
    
66. #define         WK2XXX_UT1RST        0x01
    
67. //GIER
    
68. #define         WK2XXX_UT4IE        0x08
    
69. #define         WK2XXX_UT3IE        0x04
    
70. #define         WK2XXX_UT2IE        0x02
    
71. #define         WK2XXX_UT1IE        0x01
    
72. //GIFR
    
73. #define         WK2XXX_UT4INT        0x08
    
74. #define         WK2XXX_UT3INT        0x04
    
75. #define         WK2XXX_UT2INT        0x02
    
76. #define         WK2XXX_UT1INT        0x01
    
77. //SPAGE
    
78. #define         WK2XXX_SPAGE0          0x00
    
79. #define         WK2XXX_SPAGE1   0x01
    
80. //SCR
    
81. #define         WK2XXX_SLEEPEN        0x04
    
82. #define         WK2XXX_TXEN     0x02
    
83. #define         WK2XXX_RXEN     0x01
    
84. //LCR
    
85. #define         WK2XXX_BREAK          0x20
    
86. #define         WK2XXX_IREN     0x10
    
87. #define         WK2XXX_PAEN     0x08
    
88. #define         WK2XXX_PAM1     0x04
    
89. #define         WK2XXX_PAM0     0x02
    
90. #define         WK2XXX_STPL     0x01
    
91. //FCR
    
92. //SIER
    
93. #define         WK2XXX_FERR_IEN      0x80
    
94. #define         WK2XXX_CTS_IEN       0x40
    
95. #define         WK2XXX_RTS_IEN       0x20
    
96. #define         WK2XXX_XOFF_IEN      0x10
    
97. #define         WK2XXX_TFEMPTY_IEN   0x08
    
98. #define         WK2XXX_TFTRIG_IEN    0x04
    
99. #define         WK2XXX_RXOUT_IEN     0x02
    
100. #define         WK2XXX_RFTRIG_IEN    0x01
     
101. //SIFR
     
102. #define         WK2XXX_FERR_INT      0x80
     
103. #define         WK2XXX_CTS_INT       0x40
     
104. #define         WK2XXX_RTS_INT       0x20
     
105. #define         WK2XXX_XOFF_INT      0x10
     
106. #define         WK2XXX_TFEMPTY_INT   0x08
     
107. #define         WK2XXX_TFTRIG_INT    0x04
     
108. #define         WK2XXX_RXOVT_INT     0x02
     
109. #define         WK2XXX_RFTRIG_INT    0x01
     
110. 
     
111. 
     
112. //TFCNT
     
113. //RFCNT
     
114. //FSR
     
115. #define         WK2XXX_RFOE     0x80
     
116. #define         WK2XXX_RFBI     0x40
     
117. #define         WK2XXX_RFFE     0x20
     
118. #define         WK2XXX_RFPE     0x10
     
119. #define         WK2XXX_RDAT     0x08
     
120. #define         WK2XXX_TDAT     0x04
     
121. #define         WK2XXX_TFULL    0x02
     
122. #define         WK2XXX_TBUSY    0x01
     
123. //LSR
     
124. #define         WK2XXX_OE       0x08
     
125. #define         WK2XXX_BI       0x04
     
126. #define         WK2XXX_FE       0x02
     
127. #define         WK2XXX_PE       0x01
     
128. //FWCR
     
129. 
     
130. uint16_t WK_PortSendData(uint8_t port, const void* buf, uint16_t len);
     
131. uint16_t WK_PortRecvData(uint8_t port, void* buf, uint16_t len);
     
132. void WK_PortInit(uint8_t port, uint32_t fosc, uint32_t baudrate);
     
133. void WK_IRQHandler(void);
     
134. void WK_Rst(void);
     
135. 
     
136. #endif /* SRC_WK2XXX_H_ */

复制代码

源文件

1. /*
   
2. * wk2xxx.c
   
3. *
   
4. *  Created on: Jun 17, 2021
   
5. *      Author: hello
   
6. */
   
7. 
   
8. #include "wk2xxx.h"
   
9. #include "spi.h"
   
10. 
    
11. 
    
12. //
    
13. ///
    
14. ///                            移植修改区域
    
15. ///
    
16. //
    
17. 
    
18. /// HAL库SPI句柄
    
19. #define WK_SPI_Handle (&hspi2)
    
20. 
    
21. // 拉低RST引脚
    
22. #define WK_GPIO_RST_L()    HAL_GPIO_WritePin(WK2124_RST1_GPIO_Port, WK2124_RST1_Pin, GPIO_PIN_RESET)
    
23. 
    
24. // 拉高RST引脚
    
25. #define WK_GPIO_RST_H()    HAL_GPIO_WritePin(WK2124_RST1_GPIO_Port, WK2124_RST1_Pin, GPIO_PIN_SET)
    
26. 
    
27. // 片选引脚拉低
    
28. #define WK_GPIO_SEL_L()    HAL_GPIO_WritePin(WK2124_CS1_GPIO_Port, WK2124_CS1_Pin, GPIO_PIN_RESET)
    
29. 
    
30. // 片选引脚拉高
    
31. #define WK_GPIO_SEL_H()    HAL_GPIO_WritePin(WK2124_CS1_GPIO_Port, WK2124_CS1_Pin, GPIO_PIN_SET)
    
32. 
    
33. 
    
34. static void wk_delay_ms(uint32_t nms)
    
35. {
    
36.         HAL_Delay(nms);
    
37. }
    
38. 
    
39. static uint8_t WK_SPI_ReadWriteByte(uint8_t TxData)
    
40. {
    
41.         uint8_t RxData = 0X00;
    
42.         if (HAL_SPI_TransmitReceive(WK_SPI_Handle, &TxData, &RxData, 1, 10) != HAL_OK)
    
43.         {
    
44.                 RxData = 0XFF;
    
45.         }
    
46.         return RxData;
    
47. }
    
48. 
    
49. 
    
50. 
    
51. 
    
52. //
    
53. ///
    
54. ///                            驱动程序代码
    
55. ///
    
56. //
    
57. 
    
58. 
    
59. 
    
60. /// 硬件复位（拉低复位引脚最低10毫秒进行复位）
    
61. void WK_Rst(void)
    
62. {
    
63.         WK_GPIO_RST_L();
    
64.         wk_delay_ms(50);
    
65.         WK_GPIO_RST_H();
    
66.         wk_delay_ms(50);
    
67. }
    
68. 
    
69. void WK_WriteGReg(uint8_t reg, uint8_t value)
    
70. {
    
71.         WK_GPIO_SEL_L();
    
72.         WK_SPI_ReadWriteByte(reg);
    
73.         WK_SPI_ReadWriteByte(value);
    
74.         WK_GPIO_SEL_H();
    
75. }
    
76. 
    
77. uint8_t WK_ReadGReg(uint8_t reg)
    
78. {
    
79.         uint8_t value = 0X00;
    
80.         WK_GPIO_SEL_L();
    
81.         WK_SPI_ReadWriteByte(0X40 | reg);
    
82.         value = WK_SPI_ReadWriteByte(0X00);
    
83.         WK_GPIO_SEL_H();
    
84.         return value;
    
85. }
    
86. 
    
87. void WK_WriteSReg(uint8_t port, uint8_t reg, uint8_t value)
    
88. {
    
89.         WK_GPIO_SEL_L();
    
90.         WK_SPI_ReadWriteByte(((port - 1) << 4) | reg);
    
91.         WK_SPI_ReadWriteByte(value);
    
92.         WK_GPIO_SEL_H();
    
93. }
    
94. 
    
95. uint8_t WK_ReadSReg(uint8_t port, uint8_t reg)
    
96. {
    
97.         uint8_t value = 0X00;
    
98.         WK_GPIO_SEL_L();
    
99.         WK_SPI_ReadWriteByte(0X40 | ((port - 1) << 4) | reg);
    
100.         value = WK_SPI_ReadWriteByte(0X00);
     
101.         WK_GPIO_SEL_H();
     
102.         return value;
     
103. }
     
104. 
     
105. void WK_WriteFIFO(uint8_t port, const void* buf, uint16_t len)
     
106. {
     
107.         const uint8_t* p = (const uint8_t *)buf;
     
108.         WK_GPIO_SEL_L();
     
109.         WK_SPI_ReadWriteByte(0X80 | ((port - 1) << 4));
     
110.         while (len--)
     
111.         {
     
112.                 WK_SPI_ReadWriteByte(*p++);
     
113.         }
     
114.         WK_GPIO_SEL_H();
     
115. }
     
116. 
     
117. void WK_ReadFIFO(uint8_t port, void* buf, uint16_t len)
     
118. {
     
119.         uint8_t* p = (uint8_t *)buf;
     
120.         WK_GPIO_SEL_L();
     
121.         WK_SPI_ReadWriteByte(0XC0 | ((port - 1) << 4));
     
122.         while (len--)
     
123.         {
     
124.                 *p++ = WK_SPI_ReadWriteByte(0X00);
     
125.         }
     
126.         WK_GPIO_SEL_H();
     
127. }
     
128. 
     
129. void WK_PortCalcBaudrate(uint32_t fosc, uint32_t baudrate, uint8_t* BAUD0, uint8_t* BAUD1, uint8_t* PRES)
     
130. {
     
131.         float value = (float)fosc / (float)(baudrate << 4);
     
132.         *BAUD0 = (((uint32_t)value) - 1) & 0XFF;
     
133.         *BAUD1 = ((((uint32_t)value) - 1) >> 8) & 0XFF;
     
134.         *PRES  = ((uint32_t)(value * 10)) % 10;
     
135. }
     
136. 
     
137. uint16_t WK_PortSendData(uint8_t port, const void* buf, uint16_t len)
     
138. {
     
139.         uint8_t  state = 0;
     
140.         uint16_t nsend = 0;
     
141.         state = WK_ReadSReg(port, WK2XXX_FSR);
     
142.         if (state & WK2XXX_TFULL)                    // 发送FIFO满
     
143.         {
     
144.                 nsend = 0;
     
145.         } else
     
146.         {
     
147.                 state = WK_ReadSReg(port, WK2XXX_TFCNT); // 读取发送FIFO已用空间
     
148.                 nsend = 256 - state;
     
149.                 nsend = nsend >= len ? len : nsend;
     
150.                 WK_WriteFIFO(port, buf, nsend);          // 将待发送的数据写入FIFO
     
151.         }
     
152.         return nsend;                                // 返回实际发送成功的数据量
     
153. }
     
154. 
     
155. uint16_t WK_PortRecvData(uint8_t port, void* buf, uint16_t len)
     
156. {
     
157.         uint8_t state = 0;
     
158.         uint8_t nread = 0;
     
159.         state = WK_ReadSReg(port, WK2XXX_FSR);
     
160.         if (state & WK2XXX_RDAT)                      // 接收FIFO非空
     
161.         {
     
162.                 nread = WK_ReadSReg(port, WK2XXX_RFCNT);  // 查询FIFO中的数据量
     
163.                 nread = len >= nread ? nread : len;
     
164.                 WK_ReadFIFO(port, buf, nread);            // 读取FIFO中的数据
     
165.         }
     
166.         return nread;                                 // 返回实际读取到的数据量
     
167. }
     
168. 
     
169. void WK_PortInit(uint8_t port, uint32_t fosc, uint32_t baudrate)
     
170. {
     
171.         uint8_t BAUD0 = 0, BAUD1 = 0, PRES = 0, value = 0, ret = 0;
     
172. 
     
173.         //
     
174.         // 使能子串口时钟
     
175.         //
     
176.         value = WK_ReadGReg(WK2XXX_GENA);
     
177.         value |= (1 << (port - 1));
     
178.         WK_WriteGReg(WK2XXX_GENA, value);
     
179.         ret = WK_ReadGReg(WK2XXX_GENA);
     
180. 
     
181.         //
     
182.         // 软件复位子串口
     
183.         //
     
184.         value = WK_ReadGReg(WK2XXX_GRST);
     
185.         value |= (1 << (port - 1));
     
186.         WK_WriteGReg(WK2XXX_GRST, value);
     
187.         ret = WK_ReadGReg(WK2XXX_GRST);
     
188. 
     
189.         //
     
190.         // 使能子串口总中断
     
191.         //
     
192.         value = WK_ReadGReg(WK2XXX_GIER);
     
193.         value |= (1 << (port - 1));
     
194.         WK_WriteGReg(WK2XXX_GIER, value);
     
195.         ret = WK_ReadGReg(WK2XXX_GIER);
     
196. 
     
197.         //
     
198.         // 使能子串口FIFO相关中断
     
199.         //
     
200.         value = WK_ReadSReg(port, WK2XXX_SIER);
     
201.         value |= WK2XXX_RFTRIG_IEN;                  // 接收FIFO触点中断
     
202. //        value |= WK2XXX_TFTRIG_IEN;                  // 发送FIFO触点中断
     
203. //        value |= WK2XXX_RXOUT_IEN;                   // 接收FIFO超时中断
     
204.         WK_WriteSReg(port, WK2XXX_SIER, value);
     
205.         ret = WK_ReadSReg(port, WK2XXX_SIER);
     
206. 
     
207.         //
     
208.         // 设置FCR寄存器
     
209.         //
     
210.         value = 0;
     
211.         value |= (1 << 0);  // 复位接收FIFO
     
212.         value |= (1 << 1);  // 复位发送FIFO
     
213.         value |= (1 << 2);  // 使能接收FIFO(这一步必须)
     
214.         value |= (1 << 3);  // 使能发送FIFO(这一步必须)
     
215.         value |= (0 << 4);  // 设置接收FIFO触点固定为8字节
     
216.         value |= (0 << 6);  // 设置发送FIFO触点固定为8字节
     
217.         WK_WriteSReg(port, WK2XXX_FCR, value);
     
218.         ret = WK_ReadSReg(port, WK2XXX_FCR);
     
219. 
     
220.         //
     
221.         // 切换到page1设置中断触点和波特率
     
222.         //
     
223.         WK_WriteSReg(port, WK2XXX_SPAGE, 1);
     
224.         ret = WK_ReadSReg(port, WK2XXX_SPAGE);
     
225. 
     
226.         WK_WriteSReg(port, WK2XXX_RFTL, 10);      // 设置接收触点为10个字节
     
227.         ret = WK_ReadSReg(port, WK2XXX_RFTL);
     
228. 
     
229.         WK_WriteSReg(port, WK2XXX_TFTL, 10);      // 设置发送触点为10个字节
     
230.         ret = WK_ReadSReg(port, WK2XXX_TFTL);
     
231. 
     
232.         WK_PortCalcBaudrate(fosc, baudrate, &BAUD0, &BAUD1, &PRES);  // 计算波特率
     
233. 
     
234.         WK_WriteSReg(port, WK2XXX_BAUD1, BAUD1);  // 设置BAUD1
     
235.         ret = WK_ReadSReg(port, WK2XXX_BAUD1);
     
236. 
     
237.         WK_WriteSReg(port, WK2XXX_BAUD0, BAUD0);  // 设置BAUD0
     
238.         ret = WK_ReadSReg(port, WK2XXX_BAUD0);
     
239. 
     
240.         WK_WriteSReg(port, WK2XXX_PRES, PRES);    // 设置PRES
     
241.         ret = WK_ReadSReg(port, WK2XXX_PRES);
     
242. 
     
243.         //
     
244.         // 切换回page0
     
245.         //
     
246.         WK_WriteSReg(port, WK2XXX_SPAGE, 0);
     
247.         ret = WK_ReadSReg(port, WK2XXX_SPAGE);
     
248. 
     
249.         //
     
250.         // 使能子串口收发
     
251.         //
     
252.         value = WK_ReadSReg(port, WK2XXX_SCR);
     
253.         value |= WK2XXX_TXEN;
     
254.         value |= WK2XXX_RXEN;
     
255.         WK_WriteSReg(port, WK2XXX_SCR, value);
     
256.         ret = WK_ReadSReg(port, WK2XXX_SCR);
     
257. }
     
258. 
     
259. 
     
260. // 如果irq引脚接入了单片机的外部中断引脚，将该函数放入外部中断处理函数内。
     
261. // 对于WK2124所开启的中断可以这么处理：
     
262. void WK_IRQHandler(void)
     
263. {
     
264.         int i = 0;
     
265.         uint8_t GIFR = 0, SIFR = 0;
     
266. 
     
267.         // 读取子串口全局中断寄存器
     
268.         GIFR = WK_ReadGReg(WK2XXX_GIFR);
     
269. 
     
270.         // 查询4个子串口是否发生中断
     
271.         for (i = 0; i < 4; i++)
     
272.         {
     
273.                 if ((GIFR >> i) & 0X01)
     
274.                 {
     
275.                         SIFR = WK_ReadSReg((i + 1), WK2XXX_SIFR);
     
276. 
     
277.                         // 有接收FIFO触点中断
     
278.                         if (SIFR & WK2XXX_RFTRIG_INT)
     
279.                         {
     
280.                                 // 调用WK_PortRecvData接收数据
     
281.                         }
     
282. 
     
283.                         // 有接收FIFO超时中断
     
284.                         if (SIFR & WK2XXX_RXOVT_INT)
     
285.                         {
     
286. 
     
287.                         }
     
288. 
     
289.                         // 有发送FIFO触点中断
     
290.                         if (SIFR & WK2XXX_TFTRIG_INT)
     
291.                         {
     
292. 
     
293.                         }
     
294. 
     
295.                         // 有发送FIFO空中断
     
296.                         if (SIFR & WK2XXX_TFEMPTY_INT)
     
297.                         {
     
298. 
     
299.                         }
     
300. 
     
301.                         // 有接收FIFO数据错误中断
     
302.                         if (SIFR & WK2XXX_FERR_INT)
     
303.                         {
     
304. 
     
305.                         }
     
306.                 }
     
307.         }
     
308. }
     
309. 
     
310. /*
     
311. 
     
312. int main()
     
313. {
     
314.         int nrecv = 0;
     
315.         uint8_t buffer[256];
     
316.         
     
317.         // 硬件复位一下
     
318.         WK_Rst();
     
319.         
     
320.         // 初始化四个端口
     
321.         WK_PortInit(1, 11059200, 9600);  // WK2124晶振我用的是11.0592MHz的，这个值根据实际进行修改
     
322.         WK_PortInit(2, 11059200, 9600);
     
323.         WK_PortInit(3, 11059200, 9600);
     
324.         WK_PortInit(4, 11059200, 9600);
     
325.         
     
326.         // 发送数据
     
327.         WK_PortSendData(1, "helloworld\r\n", 12);
     
328.         WK_PortSendData(2, "helloworld\r\n", 12);
     
329.         WK_PortSendData(3, "helloworld\r\n", 12);
     
330.         WK_PortSendData(4, "helloworld\r\n", 12);
     
331.         
     
332.         // 接收数据，轮训方式
     
333.         nrecv = WK_PortRecvData(1, buffer, sizeof(buffer));
     
334.         
     
335.         if(nrecv != 0)
     
336.         {
     
337.                 // 处理数据
     
338.         }
     
339.         
     
340. }
     
341. 
     
342. */
     
343. 
     
344. 
     
345. 
     
346. 
     
347. 
     
348. 
     

复制代码