• GD32F103 硬件SPI通信

    1. SPI的通信原理

    SPI既可以做主机也可以做从机。

    当做主机时。MOSI，SCK,CS都是作为输出。 而作为从机时。MOSI，SCK,CS都是作为输入。

     所以SPI的硬件电路应该实现这样的功能。

    2. GD32/STM32的SPI框图 

    1. GD32框图

    如下图做主机的数据流向：

     

    如下图做从机的数据流向： 

     

    2. STM32框图 

    通过一些寄存器的配置来控制电路。跟GD32的差不多。

    波特率配置越高，采样越快。SPI的速率越快。

    3. SPI的寄存器介绍

     1. 控制寄存器0（SPI_CTL0）

     

     

    2. 控制寄存器1（SPI_CTL1） 

    3. 状态寄存器（SPI_STAT）  

     

    4. 数据寄存器（SPI_DATA）  

    4. SPI主模式配置

     

    1. 发送数据 

    先判断发送主机发送缓冲器是否为空。

    2. 接收数据

    接收数据缓冲器是否为空。如果为空就等待，否则就接收。

     

    5. dome (硬件SPI访问w25Q32)

    NSS\SCK\MISO\MOSI  对应的 PA4\PA5\PA6\PA7引脚。

    1. 具体的SPI配置步骤。

    1. SPI时钟使能，SPI对应的GPIO时钟使能。复用时钟使能。

    2. SPI的GOIP配置。

    3. SPI的初始化配置

    4. SPI使能。

    2. 代码实现

    spi.h

    1. #ifndef _SPI_H
    2. #define _SPI_H
    3.  
    4. #include "gd32f10x.h"
    5.  
    6.  
    7. void w25qxx_rcu_init(void);
    8. void w25qxx_io_init(void);
    9. void w25qxx_spi_init(void);
    10.  
    11. #endif

    spi.c

    1. #include "spi.h"
    2.  
    3. // 使能外设时钟
    4. void w25qxx_rcu_init(void)
    5. {
    6. 	rcu_periph_clock_enable(RCU_GPIOA); //使能GPIOA时钟
    7. 	rcu_periph_clock_enable(RCU_AF);    //使能AF时钟
    8. 	rcu_periph_clock_enable(RCU_SPI0);  //使能SPI0时钟
    9. }
    10. 	
    11. // IO口进行配置，使之复用为SPI0， PA4\PA5\PA6\PA7，NSS\SCK\MISO\MOSI
    12. void w25qxx_io_init(void)
    13. {
    14. 	gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6); // MISO 浮空输入
    15. 	
    16. 	gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7); // SCK\MOSI 复用推挽
    17. 	
    18. 	gpio_init(GPIOA, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_4);// NSS片选口 普通的推挽输出
    19. }
    20. 	
    21. // SPI0初始化
    22. void w25qxx_spi_init(void)
    23. {
    24. 	spi_parameter_struct spi_struct;
    25. 	spi_struct.device_mode = SPI_MASTER;                    /*!< SPI master  做主机*/
    26.   spi_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;         /*!< SPI transfer type 全双工 */
    27.   spi_struct.frame_size =  SPI_FRAMESIZE_8BIT;              /*!< SPI frame size  一次8字节 */
    28.   spi_struct.nss = SPI_NSS_SOFT;                            /*!< SPI NSS control by software 软件CS */
    29.   spi_struct.endian = SPI_ENDIAN_MSB;                       /*!< SPI big endian or little endian  传输高字节在前*/
    30.   spi_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE; /*!< SPI clock phase and polarity 空闲低电平 第一个边沿进行采样*/
    31.   spi_struct.prescale = SPI_PSC_8;                          /*!< SPI prescaler factor 8分频*/
    32. 	spi_init(SPI0, &spi_struct);
    33. }
    34.

    w25qxx.h 

    1. #ifndef _W25QXX_SPI_H
    2. #define _W25QXX_SPI_H
    3.  
    4. #include "gd32f10x.h"
    5. #include "w25qxx_ins.h"
    6. #include "gd32f10x_spi.h"
    7.  
    8. #define W25QXX_ID_1           1
    9.  
    10. #define W25QXX_SR_ID_1        1
    11. #define W25QXX_SR_ID_2        2
    12. #define W25QXX_SR_ID_3        3
    13. void w25qxx_init(void);
    14. void w25qxx_wait_busy(void);
    15. uint8_t w25qxx_read_sr(uint8_t sregister_id);  // 读状态寄存器
    16. 	
    17. void w25qxx_read(uint8_t *p_buffer, uint32_t read_addr, uint16_t num_read_bytes);
    18.  
    19. void w25qxx_write(uint8_t *p_buffer, uint32_t write_addr, uint16_t num_write_bytes);
    20. void w25qxx_write_nocheck(uint8_t *p_buffer, uint32_t write_addr, uint16_t num_write_bytes); //
    21. void w25qxx_write_page(uint8_t *p_buffer, uint32_t write_addr, uint16_t num_write_bytes);   // page program
    22.  
    23. void w25qxx_erase_sector(uint32_t sector_addr);
    24. void w25qxx_erase_chip(void);
    25.  
    26. void w25qxx_write_enable(void);
    27. void w25qxx_write_disable(void);
    28.  
    29. void w25qxx_power_down(void);
    30. void w25qxx_wake_up(void);
    31.  
    32. void w25qxx_cs_enable(uint8_t cs_id);
    33. void w25qxx_cs_disable(uint8_t cs_id);
    34. uint8_t w25qxx_swap(uint8_t byte_to_send);
    35.  
    36.  
    37. #endif

    w25qxx.c

    1. #include "w25qxx.h"
    2. #include "spi.h"
    3.  
    4. void w25qxx_init(void){
    5. 	// 使能外设时钟
    6. 	w25qxx_rcu_init();
    7. 	
    8. 	// IO口进行配置，使之复用为SPI0， PA4\PA5\PA6\PA7，NSS\SCK\MISO\MOSI
    9. 	w25qxx_io_init();
    10. 	
    11. 	// SPI0初始化
    12. 	w25qxx_spi_init();
    13. 	// SPI使能
    14. 	spi_enable(SPI0);
    15. }
    16.  
    17.  
    18. // 如果SR-1的BUSY位为1的话，一直等待，直到BUSY位为0，结束等待
    19. void w25qxx_wait_busy(void){
    20. 	while((w25qxx_read_sr(W25QXX_SR_ID_1) & 0x01) == 0x01){
    21. 		;
    22. 	}
    23. }
    24.  
    25. // 读状态寄存器
    26. uint8_t w25qxx_read_sr(uint8_t sregister_id){
    27. 	uint8_t command, result;
    28. 	switch(sregister_id){
    29. 		case W25QXX_SR_ID_1:
    30. 			command = W25QXX_READ_STATUS_REGISTER_1;
    31. 		break;
    32. 		case W25QXX_SR_ID_2:
    33. 			command = W25QXX_READ_STATUS_REGISTER_2;
    34. 		break;
    35. 		case W25QXX_SR_ID_3:
    36. 			command = W25QXX_READ_STATUS_REGISTER_3;
    37. 		break;
    38. 		default:
    39. 			command = W25QXX_READ_STATUS_REGISTER_1;
    40. 		break;
    41. 	}
    42. 	
    43. 	w25qxx_cs_enable(W25QXX_ID_1);
    44. 	w25qxx_swap(command);
    45. 	result = w25qxx_swap(0xFF);
    46. 	w25qxx_cs_disable(W25QXX_ID_1);
    47. 	
    48. 	return result;
    49. }
    50.  
    51. // 读flash的数据
    52. // *p_buffer 读回的数据的存放位置
    53. void w25qxx_read(uint8_t *p_buffer, uint32_t read_addr, uint16_t num_read_bytes){
    54. 	uint16_t i;
    55. 	
    56. 	w25qxx_cs_enable(W25QXX_ID_1);
    57. 	
    58. 	w25qxx_swap(W25QXX_READ_DATA); //发送读数据的指令
    59. 	w25qxx_swap(read_addr >> 16);  //发送24bit地址
    60. 	w25qxx_swap(read_addr >> 8);
    61. 	w25qxx_swap(read_addr);
    62. 	
    63. 	for(i=0; i < num_read_bytes; i++){
    64. 		p_buffer[i] = w25qxx_swap(0xFF);
    65. 	}
    66. 	
    67. 	w25qxx_cs_disable(W25QXX_ID_1);
    68. }
    69.  
    70. // 
    71. uint8_t W25QXX_Buffer[4096];  //用来存放从sector读出的bytes
    72. void w25qxx_write(uint8_t *p_buffer, uint32_t write_addr, uint16_t num_write_bytes){
    73. 	uint32_t sec_num;
    74. 	uint16_t sec_remain;
    75. 	uint16_t sec_off;
    76. 	uint16_t i;
    77. 	
    78. 	sec_num	= write_addr / 4096;              //要写入的位置处在第sec_num个扇区上
    79. 	sec_off = write_addr % 4096;
    80. 	
    81. 	sec_remain = 4096 - sec_off;
    82. 	
    83. 	if(num_write_bytes <= sec_remain){
    84. 		w25qxx_read(W25QXX_Buffer, sec_num * 4096, 4096);  //扇区的数据读出来
    85. 		
    86. 		for(i = 0; i < sec_remain; i++){
    87. 			if(W25QXX_Buffer[i + sec_off] != 0xFF)  //说明这个扇区的第i+sec_off位没有擦除
    88. 				break;
    89. 		}
    90. 		
    91. 		if(i < sec_remain){ // 扇区没有擦除
    92. 			w25qxx_erase_sector(sec_num * 4096);
    93. 			for(i = 0; i < sec_remain; i++){
    94. 				W25QXX_Buffer[i + sec_off] = p_buffer[i];
    95. 			}
    96. 			w25qxx_write_nocheck(W25QXX_Buffer, sec_num * 4096, 4096);
    97. 		}else{              // 扇区sec_remain部分是擦除过的
    98. 			w25qxx_write_nocheck(p_buffer, write_addr, num_write_bytes);
    99. 		}
    100. 	}else{
    101. 		w25qxx_read(W25QXX_Buffer, sec_num * 4096, 4096);  //扇区的数据读出来
    102. 		
    103. 		for(i = 0; i < sec_remain; i++){
    104. 			if(W25QXX_Buffer[i + sec_off] != 0xFF)  //说明这个扇区的第i+sec_off位没有擦除
    105. 				break;
    106. 		}
    107. 		
    108. 		if(i < sec_remain){ // 扇区没有擦除
    109. 			w25qxx_erase_sector(sec_num * 4096);
    110. 			for(i = 0; i < sec_remain; i++){
    111. 				W25QXX_Buffer[i + sec_off] = p_buffer[i];
    112. 			}
    113. 			w25qxx_write_nocheck(W25QXX_Buffer, sec_num * 4096, 4096);
    114. 		}else{              // 扇区sec_remain部分是擦除过的
    115. 			w25qxx_write_nocheck(p_buffer, write_addr, sec_remain);
    116. 		}
    117. 		
    118. 		write_addr += sec_remain;
    119. 		p_buffer += sec_remain;
    120. 		num_write_bytes -= sec_remain;
    121. 		w25qxx_write(p_buffer, write_addr, num_write_bytes);
    122. 	}
    123. 		
    124. 	//判断读出来的数据是否都为0xFF
    125. 	;//扇区是否删除
    126. 	 //判断是否跨页
    127. }
    128.  
    129. // 调用之前先确保扇区删除
    130. void w25qxx_write_nocheck(uint8_t *p_buffer, uint32_t write_addr, uint16_t num_write_bytes){
    131. 	uint16_t page_remain = 256 - write_addr % 256;
    132. 	
    133. 	if(num_write_bytes <= page_remain){
    134. 		w25qxx_write_page(p_buffer, write_addr, num_write_bytes);
    135. 	}else{
    136. 		w25qxx_write_page(p_buffer, write_addr, page_remain);
    137. 		p_buffer += page_remain;
    138. 		write_addr += page_remain;
    139. 		num_write_bytes -= page_remain;
    140. 		w25qxx_write_nocheck(p_buffer, write_addr, num_write_bytes);
    141. 	}
    142. }
    143.  
    144. // page program
    145. // 保证没有跨页写的前提下调用此函数往某个页上写内容
    146. void w25qxx_write_page(uint8_t *p_buffer, uint32_t write_addr, uint16_t num_write_bytes){
    147. 	uint16_t i;
    148. 	
    149. 	w25qxx_write_enable();
    150. 	
    151. 	w25qxx_cs_enable(W25QXX_ID_1);
    152. 	w25qxx_swap(W25QXX_PAGE_PROGRAM);
    153. 	w25qxx_swap(write_addr >> 16);  //发送24bit地址
    154. 	w25qxx_swap(write_addr >> 8);
    155. 	w25qxx_swap(write_addr);
    156. 	
    157. 	for(i = 0; i < num_write_bytes; i++){
    158. 		w25qxx_swap(p_buffer[i]);
    159. 	}
    160. 	w25qxx_cs_disable(W25QXX_ID_1);
    161. 	
    162. 	w25qxx_wait_busy();
    163. }
    164.  
    165. void w25qxx_erase_sector(uint32_t sector_addr){
    166. 	w25qxx_write_enable();
    167. 	
    168. 	w25qxx_cs_enable(W25QXX_ID_1);
    169. 	w25qxx_swap(W25QXX_SECTOR_ERASE_4KB);
    170. 	w25qxx_swap(sector_addr >> 16);
    171. 	w25qxx_swap(sector_addr >> 8);
    172. 	w25qxx_swap(sector_addr);
    173. 	w25qxx_cs_disable(W25QXX_ID_1);
    174. 	
    175. 	w25qxx_wait_busy();
    176. }
    177.  
    178. void w25qxx_erase_chip(void){
    179. 	w25qxx_write_enable();
    180. 	
    181. 	w25qxx_cs_enable(W25QXX_ID_1);
    182. 	w25qxx_swap(W25QXX_CHIP_ERASE);
    183. 	w25qxx_cs_disable(W25QXX_ID_1);
    184. 	
    185. 	w25qxx_wait_busy();
    186. }
    187.  
    188. void w25qxx_write_enable(void){
    189. 	w25qxx_cs_enable(W25QXX_ID_1);
    190. 	w25qxx_swap(W25QXX_WRITE_ENABLE);
    191. 	w25qxx_cs_disable(W25QXX_ID_1);
    192. }
    193.  
    194. void w25qxx_write_disable(void){
    195. 	w25qxx_cs_enable(W25QXX_ID_1);
    196. 	w25qxx_swap(W25QXX_WRITE_DISABLE);
    197. 	w25qxx_cs_disable(W25QXX_ID_1);
    198. }
    199.  
    200. // 低电量休眠
    201. void w25qxx_power_down(void){
    202. 	w25qxx_cs_enable(W25QXX_ID_1);
    203. 	w25qxx_swap(W25QXX_POWER_DOWN);
    204. 	w25qxx_cs_disable(W25QXX_ID_1);
    205. }
    206.  
    207. // 唤醒
    208. void w25qxx_wake_up(void){
    209. 	w25qxx_cs_enable(W25QXX_ID_1);
    210. 	w25qxx_swap(W25QXX_RELEASE_POWER_DOWN_HPM_DEVICE_ID);
    211. 	w25qxx_cs_disable(W25QXX_ID_1);
    212. }
    213.  
    214. /*
    215. brief：使能片选引脚cs
    216. cs_id: cs引脚的序号，即第几个w25qxx flash
    217. */
    218. void w25qxx_cs_enable(uint8_t cs_id){
    219. 	switch(cs_id){
    220. 		case W25QXX_ID_1:
    221. 			gpio_bit_reset(GPIOA, GPIO_PIN_4);
    222. 		break;
    223. 		default:
    224. 			break;
    225. 	}
    226. }
    227.  
    228. void w25qxx_cs_disable(uint8_t cs_id){
    229. 	switch(cs_id){
    230. 		case W25QXX_ID_1:
    231. 			gpio_bit_set(GPIOA, GPIO_PIN_4);
    232. 		break;
    233. 		default:
    234. 			break;
    235. 	}
    236. }
    237.  
    238. /*
    239. 主从数据交换
    240. */
    241. uint8_t w25qxx_swap(uint8_t byte_to_send){
    242. 	while(spi_i2s_flag_get(SPI0, SPI_FLAG_TBE) == RESET){ // 等待SPI发送缓冲器为空
    243. 		;
    244. 	}
    245. 	spi_i2s_data_transmit(SPI0, byte_to_send);            // 把数据放到发生缓冲器
    246. 	while(spi_i2s_flag_get(SPI0, SPI_FLAG_TRANS) == SET){ // 等待通信结束
    247. 		;
    248. 	}
    249. 	
    250. 	while(spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE) == RESET){ // 等待SPI接收缓冲器非空
    251. 		;
    252. 	}	
    253. 	return spi_i2s_data_receive(SPI0); /* 把接收到的数据返回（从接收缓冲器里拿出） */
    254. }

  • 相关阅读:
    AtCoder abc148
    第七讲（二）：双指针，指针运用
    《DREEAM Guiding Attention with Evidence for Improving Document-Level Relation Extraction》阅读笔记
    Elasticsearch之join关联查询
    前端JavaScript入门到精通，javascript核心进阶ES6语法、API、js高级等基础知识和实战 —— Web APIs（六）
    两个难搞的Java Error/Exception
    四面大厂自动化测试岗位，跳槽成功涨薪3倍
    leetcode单调栈系列
    wxpython：wx.grid 表格显示 Excel xlsx文件
    java毕业设计基于javaweb+mysql数据库实现的在线学习网站|在线课堂含论文+开题报告
  • 原文地址：https://blog.csdn.net/qq_41328470/article/details/133690947