devbox
思考机器2
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32F4 SPI RX/TX DMA 读写FLASH数据_dma能写flash吗

作者：思考机器2 | 2024-01-31 14:08:59

赞

踩

dma能写flash吗

STM32 使用DMA读写FLASH数据需要注意以下几点：

1.SPI全双工模式下，无论读写FLASH数据均需要同时使能RX/TX DMA。

2.写数据时回读数据应当丢弃，读数据时应当发送0xff来启动SPI读周期。

3.使用DMA时应当使能DMA Stream，然后再使能SPI DMA请求。

 

以下为测试代码，为省事，没启动串口提供打印信息，可在读出FLASH数据后通过断点查看数据。

  1. #include <stdbool.h>
  2. #include <stm32f4xx_dma.h>
  3. #include <stm32f4xx_gpio.h>
  4. #include <stm32f4xx_spi.h>
  5.  
  6. #define FLASH_PAGE_SIZE            256
  7.  
  8. static volatile int g_rx_flag = 0;
  9. static volatile int g_tx_flag = 0;
  10.  
  11. static void spi_wait_rx(void)
  12. {
  13.    while(!g_rx_flag);
  14.    g_rx_flag = 0;
  15. }
  16.  
  17. static void spi_post_rx(void)
  18. {
  19.    g_rx_flag = 1;
  20. }
  21.  
  22.  
  23. static void spi_wait_tx(void)
  24. {
  25.    while(!g_tx_flag);
  26.    g_tx_flag = 0;
  27. }
  28.  
  29. static void spi_post_tx(void)
  30. {
  31.    g_tx_flag = 1;
  32. }
  33.  
  34. static void spi_do_delay(uint16_t n)
  35. { 
  36.   uint16_t t = n;
  37.   while (-- t);
  38. }
  39.  
  40. uint8_t spi_byte_transfer(uint8_t Dat)
  41. {
  42.   while ((SPI3->SR & SPI_I2S_FLAG_TXE) == 0);
  43.   SPI3->DR = Dat;
  44.   while ((SPI3->SR & SPI_I2S_FLAG_RXNE) == 0);
  45.   return ((uint8_t)(SPI3->DR));
  46. }
  47.  
  48. uint8_t spi_readbyte(void)
  49. {
  50.   return spi_byte_transfer(0xA5);
  51. }
  52.  
  53. /* 使用 GPIO6 作为 CS 信号
  54.  */
  55. static void spi_chip_select(bool select)
  56. {
  57.     spi_do_delay(5);
  58.     
  59.     if (select == true)
  60.     {
  61.         GPIOB->BSRRH = GPIO_Pin_6;
  62.     }
  63.     else
  64.     {
  65.         GPIOB->BSRRL = GPIO_Pin_6;
  66.     }
  67.     
  68.     spi_do_delay(5);
  69. }
  70.  
  71. void flash_wait_write(void)
  72. {
  73.   uint8_t status = 0;
  74.   
  75.   spi_chip_select(true);
  76.   spi_byte_transfer(0x05);
  77.   do
  78.   {
  79.     status = spi_byte_transfer(0xA5);
  80.   } while (status & 0x01);
  81.   
  82.   spi_chip_select(false);
  83. }
  84.  
  85. void flash_enable_write(void)
  86. {
  87.   spi_chip_select(true);
  88.   spi_byte_transfer(0x06);
  89.   spi_chip_select(false);
  90. }
  91.  
  92. void flash_write_status(uint8_t value)
  93. {
  94.   flash_enable_write();
  95.   
  96.   spi_chip_select(true);
  97.   spi_byte_transfer(0x01);
  98.   spi_byte_transfer(value);
  99.   
  100.   spi_chip_select(false);
  101.   
  102.   flash_wait_write();
  103. }
  104.  
  105. void flash_disable_write(void)
  106. {
  107.   flash_write_status(0);
  108. }
  109.  
  110. uint32_t flash_read_identify(void)
  111. {
  112.   uint8_t byte0 = 0, byte1 = 0, byte2 = 0;
  113.   
  114.   spi_chip_select(true);
  115.   
  116.   spi_byte_transfer(0x9F);
  117.   byte0 = spi_byte_transfer(0xA5);
  118.   byte1 = spi_byte_transfer(0xA5);
  119.   byte2 = spi_byte_transfer(0xA5);
  120.   
  121.   spi_chip_select(false);
  122.   
  123.   return ((byte0 << 16) | (byte1 << 8) | (byte2 << 0));
  124. }
  125.  
  126. void flash_erase_sector(uint32_t SectorAddr)
  127. {
  128.   flash_enable_write();
  129.   
  130.   spi_chip_select(true);
  131.   spi_byte_transfer(0x20);
  132.   spi_byte_transfer((SectorAddr >> 16) & 0xFF);
  133.   spi_byte_transfer((SectorAddr >>  8) & 0xFF);
  134.   spi_byte_transfer((SectorAddr >>  0) & 0xFF);
  135.   spi_chip_select(false);
  136.   
  137.   flash_wait_write();
  138. }
  139.  
  140. /**
  141.  * 启动SPI DMA通道
  142.  * buffer      缓冲区指针
  143.  * length      缓冲区数据长度，
  144.  *             如果 isread = true 表示需要从 flash 中读取多少个字节。
  145.  *             如果 isread = false 表示需要向 flash 写入多少个字节。
  146.  * isread      true = 读，false = 写
  147.  * 
  148.  */
  149. void flash_start_dma(uint8_t *buffer, uint32_t length, uint8_t isread)
  150. {
  151.     uint32_t temp = 0xffffffff;
  152.     DMA_InitTypeDef DMA_InitStructure;
  153.  
  154.     
  155.     DMA_StructInit(&DMA_InitStructure);
  156.     DMA_DeInit(DMA1_Stream0);
  157.     DMA_DeInit(DMA1_Stream7);
  158.     while(DMA_GetCmdStatus(DMA1_Stream0) != DISABLE);
  159.     while(DMA_GetCmdStatus(DMA1_Stream7) != DISABLE);
  160.  
  161.     /* DMA1 channel 0 stream0 --- 配置 SPI3-RX DMA */
  162.     DMA_InitStructure.DMA_Channel = DMA_Channel_0;
  163.     DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI3->DR;
  164.     
  165.     if (isread == true)
  166.     {
  167.         /* 读方式下回读数据放到 buffer 中*/
  168.         DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buffer;
  169.         DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  170.     }
  171.     else
  172.     {
  173.         /* 写方式下回读数据丢弃 */
  174.         DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)&temp;
  175.         DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
  176.     }
  177.  
  178.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  179.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
  180.     DMA_InitStructure.DMA_BufferSize = length;
  181.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  182.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  183.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  184.     DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  185.     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
  186.     DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  187.     DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  188.     DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  189.     DMA_Init(DMA1_Stream0, &DMA_InitStructure);
  190.     
  191.     /* DMA1 channel 0 stream7 --- 配置 SPI3-TX DMA */
  192.     DMA_StructInit(&DMA_InitStructure);
  193.     
  194.     DMA_InitStructure.DMA_Channel = DMA_Channel_0;
  195.     DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&SPI3->DR;
  196.  
  197.     if (isread == true)
  198.     {
  199.         /* 读方式下发送 0xff */
  200.         DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)&temp;
  201.         DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
  202.     }
  203.     else
  204.     {
  205.         /* 写方式下发送 buffer 数据*/
  206.         DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)buffer;
  207.         DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  208.     }
  209.     
  210.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  211.     DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
  212.     DMA_InitStructure.DMA_BufferSize = length;  
  213.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  214.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  215.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  216.     DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
  217.     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
  218.     DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
  219.     DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
  220.     DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
  221.     DMA_Init(DMA1_Stream7, &DMA_InitStructure);
  222.  
  223.     /* 1.开启 DMA 数据流传输完成中断 */
  224.     DMA_ITConfig(DMA1_Stream0, DMA_IT_TC, ENABLE);
  225.     DMA_ITConfig(DMA1_Stream7, DMA_IT_TC, ENABLE);
  226.  
  227.     /* 2.使能 DMA 数据流 */
  228.     DMA_Cmd(DMA1_Stream0, ENABLE);
  229.     DMA_Cmd(DMA1_Stream7, ENABLE);
  230.  
  231.     /* 3.使能 SPI DMA 请求 */
  232.     SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Rx|SPI_I2S_DMAReq_Tx, ENABLE);
  233.  
  234.     /* 5.等待 DMA 传输完成 */
  235.     spi_wait_tx();
  236.     spi_wait_rx();
  237. }
  238.  
  239. void DMA1_Stream7_IRQHandler(void)
  240. {
  241.     if (DMA_GetFlagStatus(DMA1_Stream7, DMA_FLAG_TCIF7) != RESET)
  242.     {
  243.         /* 1.清中断标志 */
  244.         DMA_ClearFlag(DMA1_Stream7, DMA_FLAG_TCIF7);
  245.         /* 2.禁能 DMA   传输完成中断 */
  246.         DMA_ITConfig(DMA1_Stream7, DMA_IT_TC, DISABLE);
  247.         /* 3.禁能 SPI TX DMA   请求 */
  248.         SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Tx, DISABLE);
  249.         /* 4.禁能 DMA Stream */
  250.         DMA_Cmd(DMA1_Stream7, DISABLE);
  251.         /* 5.通知应用程序 TX 传输完成 */
  252.         spi_post_tx();
  253.     }
  254. }
  255.  
  256. void DMA1_Stream0_IRQHandler(void)
  257. {
  258.     if (DMA_GetFlagStatus(DMA1_Stream0, DMA_FLAG_TCIF0) != RESET)
  259.     {
  260.         /* 1.清中断标志 */
  261.         DMA_ClearFlag(DMA1_Stream0, DMA_FLAG_TCIF0);
  262.         /* 2.禁能 DMA   传输完成中断 */
  263.         DMA_ITConfig(DMA1_Stream0, DMA_IT_TC, DISABLE);
  264.         /* 3.禁能 SPI TX DMA   请求 */
  265.         SPI_I2S_DMACmd(SPI3, SPI_I2S_DMAReq_Rx, DISABLE);
  266.         /* 4.禁能 DMA Stream */
  267.         DMA_Cmd(DMA1_Stream0, DISABLE); 
  268.         /* 6.通知应用程序 RX 传输完成 */
  269.         spi_post_rx();
  270.     }
  271. }
  272.  
  273. void flash_write_page(uint8_t* buffer, uint32_t addr)
  274. {
  275.   flash_enable_write();
  276.   
  277.   spi_chip_select(true);
  278.   spi_byte_transfer(0x02);
  279.   spi_byte_transfer((addr >> 16) & 0xFF);
  280.   spi_byte_transfer((addr >>  8) & 0xFF);
  281.   spi_byte_transfer((addr >>  0) & 0xFF);
  282.  
  283.   flash_start_dma(buffer, FLASH_PAGE_SIZE, false);
  284.  
  285.   spi_chip_select(false);
  286.   flash_wait_write();
  287. }
  288.  
  289. void flash_read_page(uint8_t *buffer, uint32_t addr)
  290. {
  291.     spi_chip_select(true);
  292.     spi_byte_transfer(0x03);
  293.     spi_byte_transfer((addr >> 16) & 0xFF);
  294.     spi_byte_transfer((addr >>  8) & 0xFF);
  295.     spi_byte_transfer((addr >>  0) & 0xFF);
  296.  
  297.     flash_start_dma(buffer, FLASH_PAGE_SIZE, true);
  298.     spi_chip_select(false);
  299. }
  300.  
  301.  
  302. void flash_init(void)
  303. {
  304.     GPIO_InitTypeDef GPIO_InitStructure;
  305.     NVIC_InitTypeDef NVIC_InitStructure;
  306.  
  307.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  308.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
  309.  
  310.     SPI_InitTypeDef  SPI_InitStructure;  
  311.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
  312.  
  313.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource3, GPIO_AF_SPI3);
  314.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_SPI3);
  315.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource5, GPIO_AF_SPI3);
  316.  
  317.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  318.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  319.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  320.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
  321.  
  322.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_5 | GPIO_Pin_4;
  323.     GPIO_Init(GPIOB, &GPIO_InitStructure);
  324.  
  325.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_OUT;
  326.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  327.     GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_UP;
  328.  
  329.     GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6;
  330.     GPIO_Init(GPIOB, &GPIO_InitStructure);
  331.  
  332.     SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  333.     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
  334.     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  335.     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  336.     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  337.     SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  338.     SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  339.     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  340.     SPI_InitStructure.SPI_CRCPolynomial = 7;
  341.     SPI_Init(SPI3, &SPI_InitStructure);
  342.     SPI_Cmd(SPI3, ENABLE);
  343.  
  344.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream7_IRQn;
  345.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  346.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  347.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  348.     NVIC_Init(&NVIC_InitStructure);
  349.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Stream0_IRQn;
  350.     NVIC_Init(&NVIC_InitStructure);
  351.  
  352.     spi_chip_select(false);
  353. }
  354.  
  355.  
  356. uint8_t wbuffer[512];
  357. uint8_t rbuffer[512];
  358.  
  359. int main(void)
  360. {
  361.     int i = 0;
  362.     
  363.     flash_init();
  364.  
  365.     /* 初始化测试数据 */
  366.     for (i = 0; i < 512; i++)
  367.     {
  368.         wbuffer[i] = (uint8_t)(i+9);
  369.     }
  370.  
  371.     flash_erase_sector(0);
  372.     flash_read_page(rbuffer, 0);    /* 在此处打断点查看数据 */
  373.     flash_write_page(wbuffer, 0);
  374.     flash_read_page(rbuffer, 0);    /* 在此处打断点查看数据 */
  375.  
  376.     while(1);
  377. }
  378.

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/50699
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号