21ic电子技术开发论坛 › 单片机与嵌入式系统 › 雅特力AT32 MCU › 【AT-START-L021测评】+ spiflash读写测试
返回列表 发新帖我要提问

[AT32L021] 【AT-START-L021测评】+ spiflash读写测试

[复制链接]
 楼主| tlled 发表于 2024-12-2 00:13 | 显示全部楼层 |阅读模式
FLASH读写, SPIFLASH, flash, pi, 测试
测试spiflash存储器读写。

一、硬件部分

测试使用SPI1接口。
001.png

二、程序部分

2.1、配置SPI1
spi1初始化部分程序可以使用软件AT32_Work_Bench生成
002.png

2.2、spi-flash.c
复制
  1. /**
    

  2.   **************************************************************************
    

  3.   * [url=home.php?mod=space&uid=288409]@file[/url]     spi_flash.c
    

  4.   * [url=home.php?mod=space&uid=247401]@brief[/url]    spi_flash source code
    

  5.   **************************************************************************
    

  6.   *                       Copyright notice & Disclaimer
    

  7.   *
    

  8.   * The software Board Support Package (BSP) that is made available to
    

  9.   * download from Artery official website is the copyrighted work of Artery.
    

  10.   * Artery authorizes customers to use, copy, and distribute the BSP
    

  11.   * software and its related documentation for the purpose of design and
    

  12.   * development in conjunction with Artery microcontrollers. Use of the
    

  13.   * software is governed by this copyright notice and the following disclaimer.
    

  14.   *
    

  15.   * THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES,
    

  16.   * GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS,
    

  17.   * TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR
    

  18.   * STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS,
    

  19.   * INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
    

  20.   * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
    

  21.   *
    

  22.   **************************************************************************
    

  23.   */
    


  24. 

  25. #include "spiflash/spi_flash.h"
    


  26. 

  27. /** @addtogroup AT32L021_periph_examples
    

  28.   * @{
    

  29.   */
    


  30. 

  31. /** @addtogroup 021_SPI_w25q_flash
    

  32.   * @{
    

  33.   */
    


  34. 

  35. uint8_t spiflash_sector_buf[SPIF_SECTOR_SIZE];
    


  36. 

  37. /**
    

  38.   * @brief  spi configuration.
    

  39.   * @param  none
    

  40.   * @retval none
    

  41.   */
    

  42. void spiflash_init(void)
    

  43. {
    

  44.   gpio_init_type gpio_initstructure;
    

  45.   spi_init_type spi_init_struct;
    


  46. 

  47.   crm_periph_clock_enable(CRM_GPIOA_PERIPH_CLOCK, TRUE);
    

  48.   crm_periph_clock_enable(CRM_DMA1_PERIPH_CLOCK, TRUE);
    

  49.   
    

  50.   gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE5, GPIO_MUX_0);
    

  51.   gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE6, GPIO_MUX_0);
    

  52.   gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE7, GPIO_MUX_0);
    

  53.   
    

  54.   /* software cs, pa15 as a general io to control flash cs */
    

  55.   gpio_initstructure.gpio_out_type       = GPIO_OUTPUT_PUSH_PULL;
    

  56.   gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  57.   gpio_initstructure.gpio_mode           = GPIO_MODE_OUTPUT;
    

  58.   gpio_initstructure.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    

  59.   gpio_initstructure.gpio_pins           = GPIO_PINS_15;
    

  60.   gpio_init(GPIOA, &gpio_initstructure);
    


  61. 

  62.   /* sck */
    

  63.   gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  64.   gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    

  65.   gpio_initstructure.gpio_pins           = GPIO_PINS_5;
    

  66.   gpio_init(GPIOA, &gpio_initstructure);
    


  67. 

  68.   /* miso */
    

  69.   gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  70.   gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    

  71.   gpio_initstructure.gpio_pins           = GPIO_PINS_6;
    

  72.   gpio_init(GPIOA, &gpio_initstructure);
    


  73. 

  74.   /* mosi */
    

  75.   gpio_initstructure.gpio_pull           = GPIO_PULL_UP;
    

  76.   gpio_initstructure.gpio_mode           = GPIO_MODE_MUX;
    

  77.   gpio_initstructure.gpio_pins           = GPIO_PINS_7;
    

  78.   gpio_init(GPIOA, &gpio_initstructure);
    


  79. 

  80.   FLASH_CS_HIGH();
    

  81.   crm_periph_clock_enable(CRM_SPI1_PERIPH_CLOCK, TRUE);
    

  82.   spi_default_para_init(&spi_init_struct);
    

  83.   spi_init_struct.transmission_mode = SPI_TRANSMIT_FULL_DUPLEX;
    

  84.   spi_init_struct.master_slave_mode = SPI_MODE_MASTER;
    

  85.   spi_init_struct.mclk_freq_division = SPI_MCLK_DIV_8;
    

  86.   spi_init_struct.first_bit_transmission = SPI_FIRST_BIT_MSB;
    

  87.   spi_init_struct.frame_bit_num = SPI_FRAME_8BIT;
    

  88.   spi_init_struct.clock_polarity = SPI_CLOCK_POLARITY_HIGH;
    

  89.   spi_init_struct.clock_phase = SPI_CLOCK_PHASE_2EDGE;
    

  90.   spi_init_struct.cs_mode_selection = SPI_CS_SOFTWARE_MODE;
    

  91.   spi_init(SPI1, &spi_init_struct);
    

  92.   spi_enable(SPI1, TRUE);
    

  93. }
    


  94. 

  95. /**
    

  96.   * @brief  write data to flash
    

  97.   * @param  pbuffer: the pointer for data buffer
    

  98.   * @param  write_addr: the address where the data is written
    

  99.   * @param  length: buffer length
    

  100.   * @retval none
    

  101.   */
    

  102. void spiflash_write(uint8_t *pbuffer, uint32_t write_addr, uint32_t length)
    

  103. {
    

  104.   uint32_t sector_pos;
    

  105.   uint16_t sector_offset;
    

  106.   uint16_t sector_remain;
    

  107.   uint16_t index;
    

  108.   uint8_t *spiflash_buf;
    

  109.   spiflash_buf = spiflash_sector_buf;
    


  110. 

  111.   /* sector address */
    

  112.   sector_pos = write_addr / SPIF_SECTOR_SIZE;
    


  113. 

  114.   /* address offset in a sector */
    

  115.   sector_offset = write_addr % SPIF_SECTOR_SIZE;
    


  116. 

  117.   /* the remain in a sector */
    

  118.   sector_remain = SPIF_SECTOR_SIZE - sector_offset;
    

  119.   if(length <= sector_remain)
    

  120.   {
    

  121.     /* smaller than a sector size */
    

  122.     sector_remain = length;
    

  123.   }
    

  124.   while(1)
    

  125.   {
    

  126.     /* read a sector */
    

  127.     spiflash_read(spiflash_buf, sector_pos * SPIF_SECTOR_SIZE, SPIF_SECTOR_SIZE);
    


  128. 

  129.     /* validate the read erea */
    

  130.     for(index = 0; index < sector_remain; index++)
    

  131.     {
    

  132.       if(spiflash_buf[sector_offset + index] != 0xFF)
    

  133.       {
    

  134.         /* there are some data not equal 0xff, so this secotr needs erased */
    

  135.         break;
    

  136.       }
    

  137.     }
    

  138.     if(index < sector_remain)
    

  139.     {
    

  140.       /* erase the sector */
    

  141.       spiflash_sector_erase(sector_pos);
    


  142. 

  143.       /* copy the write data */
    

  144.       for(index = 0; index < sector_remain; index++)
    

  145.       {
    

  146.         spiflash_buf[index + sector_offset] = pbuffer[index];
    

  147.       }
    

  148.       spiflash_write_nocheck(spiflash_buf, sector_pos * SPIF_SECTOR_SIZE, SPIF_SECTOR_SIZE); /* program the sector */
    

  149.     }
    

  150.     else
    

  151.     {
    

  152.       /* write directly in the erased area */
    

  153.       spiflash_write_nocheck(pbuffer, write_addr, sector_remain);
    

  154.     }
    

  155.     if(length == sector_remain)
    

  156.     {
    

  157.       /* write end */
    

  158.       break;
    

  159.     }
    

  160.     else
    

  161.     {
    

  162.       /* go on writing */
    

  163.       sector_pos++;
    

  164.       sector_offset = 0;
    


  165. 

  166.       pbuffer += sector_remain;
    

  167.       write_addr += sector_remain;
    

  168.       length -= sector_remain;
    

  169.       if(length > SPIF_SECTOR_SIZE)
    

  170.       {
    

  171.         /* could not write the remain data in the next sector */
    

  172.         sector_remain = SPIF_SECTOR_SIZE;
    

  173.       }
    

  174.       else
    

  175.       {
    

  176.         /* could write the remain data in the next sector */
    

  177.         sector_remain = length;
    

  178.       }
    

  179.     }
    

  180.   }
    

  181. }
    


  182. 

  183. /**
    

  184.   * @brief  read data from flash
    

  185.   * @param  pbuffer: the pointer for data buffer
    

  186.   * @param  read_addr: the address where the data is read
    

  187.   * @param  length: buffer length
    

  188.   * @retval none
    

  189.   */
    

  190. void spiflash_read(uint8_t *pbuffer, uint32_t read_addr, uint32_t length)
    

  191. {
    

  192.   FLASH_CS_LOW();
    

  193.   spi_byte_write(SPIF_READDATA); /* send instruction */
    

  194.   spi_byte_write((uint8_t)((read_addr) >> 16)); /* send 24-bit address */
    

  195.   spi_byte_write((uint8_t)((read_addr) >> 8));
    

  196.   spi_byte_write((uint8_t)read_addr);
    

  197.   spi_bytes_read(pbuffer, length);
    

  198.   FLASH_CS_HIGH();
    

  199. }
    


  200. 

  201. /**
    

  202.   * @brief  erase a sector data
    

  203.   * @param  erase_addr: sector address to erase
    

  204.   * @retval none
    

  205.   */
    

  206. void spiflash_sector_erase(uint32_t erase_addr)
    

  207. {
    

  208.   erase_addr *= SPIF_SECTOR_SIZE; /* translate sector address to byte address */
    

  209.   spiflash_write_enable();
    

  210.   spiflash_wait_busy();
    

  211.   FLASH_CS_LOW();
    

  212.   spi_byte_write(SPIF_SECTORERASE);
    

  213.   spi_byte_write((uint8_t)((erase_addr) >> 16));
    

  214.   spi_byte_write((uint8_t)((erase_addr) >> 8));
    

  215.   spi_byte_write((uint8_t)erase_addr);
    

  216.   FLASH_CS_HIGH();
    

  217.   spiflash_wait_busy();
    

  218. }
    


  219. 

  220. /**
    

  221.   * @brief  write data without check
    

  222.   * @param  pbuffer: the pointer for data buffer
    

  223.   * @param  write_addr: the address where the data is written
    

  224.   * @param  length: buffer length
    

  225.   * @retval none
    

  226.   */
    

  227. void spiflash_write_nocheck(uint8_t *pbuffer, uint32_t write_addr, uint32_t length)
    

  228. {
    

  229.   uint16_t page_remain;
    


  230. 

  231.   /* remain bytes in a page */
    

  232.   page_remain = SPIF_PAGE_SIZE - write_addr % SPIF_PAGE_SIZE;
    

  233.   if(length <= page_remain)
    

  234.   {
    

  235.     /* smaller than a page size */
    

  236.     page_remain = length;
    

  237.   }
    

  238.   while(1)
    

  239.   {
    

  240.     spiflash_page_write(pbuffer, write_addr, page_remain);
    

  241.     if(length == page_remain)
    

  242.     {
    

  243.       /* all data are programmed */
    

  244.       break;
    

  245.     }
    

  246.     else
    

  247.     {
    

  248.       /* length > page_remain */
    

  249.       pbuffer += page_remain;
    

  250.       write_addr += page_remain;
    


  251. 

  252.       /* the remain bytes to be prorammed */
    

  253.       length -= page_remain;
    

  254.       if(length > SPIF_PAGE_SIZE)
    

  255.       {
    

  256.         /* can be progrmmed a page at a time */
    

  257.         page_remain = SPIF_PAGE_SIZE;
    

  258.       }
    

  259.       else
    

  260.       {
    

  261.         /* smaller than a page size */
    

  262.         page_remain = length;
    

  263.       }
    

  264.     }
    

  265.   }
    

  266. }
    


  267. 

  268. /**
    

  269.   * @brief  write a page data
    

  270.   * @param  pbuffer: the pointer for data buffer
    

  271.   * @param  write_addr: the address where the data is written
    

  272.   * @param  length: buffer length
    

  273.   * @retval none
    

  274.   */
    

  275. void spiflash_page_write(uint8_t *pbuffer, uint32_t write_addr, uint32_t length)
    

  276. {
    

  277.   if((0 < length) && (length <= SPIF_PAGE_SIZE))
    

  278.   {
    

  279.     /* set write enable */
    

  280.     spiflash_write_enable();
    


  281. 

  282.     FLASH_CS_LOW();
    


  283. 

  284.     /* send instruction */
    

  285.     spi_byte_write(SPIF_PAGEPROGRAM);
    


  286. 

  287.     /* send 24-bit address */
    

  288.     spi_byte_write((uint8_t)((write_addr) >> 16));
    

  289.     spi_byte_write((uint8_t)((write_addr) >> 8));
    

  290.     spi_byte_write((uint8_t)write_addr);
    

  291.     spi_bytes_write(pbuffer,length);
    


  292. 

  293.     FLASH_CS_HIGH();
    


  294. 

  295.     /* wait for program end */
    

  296.     spiflash_wait_busy();
    

  297.   }
    

  298. }
    


  299. 

  300. /**
    

  301.   * @brief  write data continuously
    

  302.   * @param  pbuffer: the pointer for data buffer
    

  303.   * @param  length: buffer length
    

  304.   * @retval none
    

  305.   */
    

  306. void spi_bytes_write(uint8_t *pbuffer, uint32_t length)
    

  307. {
    

  308.   volatile uint8_t dummy_data;
    


  309. 

  310. #if defined(SPI_TRANS_DMA)
    

  311.   dma_init_type dma_init_struct;
    

  312.   dma_reset(DMA1_CHANNEL2);
    

  313.   dma_reset(DMA1_CHANNEL3);
    

  314.   
    

  315.   dma_flexible_config(DMA1, FLEX_CHANNEL2, DMA_FLEXIBLE_SPI2_RX);
    

  316.   dma_flexible_config(DMA1, FLEX_CHANNEL3, DMA_FLEXIBLE_SPI2_TX);
    

  317.   
    

  318.   dma_default_para_init(&dma_init_struct);
    

  319.   dma_init_struct.buffer_size = length;
    

  320.   dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
    

  321.   dma_init_struct.memory_base_addr = (uint32_t)&dummy_data;
    

  322.   dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
    

  323.   dma_init_struct.memory_inc_enable = FALSE;
    

  324.   dma_init_struct.peripheral_base_addr = (uint32_t)(&SPI2->dt);
    

  325.   dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
    

  326.   dma_init_struct.peripheral_inc_enable = FALSE;
    

  327.   dma_init_struct.priority = DMA_PRIORITY_VERY_HIGH;
    

  328.   dma_init_struct.loop_mode_enable = FALSE;
    

  329.   dma_init(DMA1_CHANNEL2, &dma_init_struct);
    


  330. 

  331.   dma_init_struct.buffer_size = length;
    

  332.   dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
    

  333.   dma_init_struct.memory_base_addr = (uint32_t)pbuffer;
    

  334.   dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
    

  335.   dma_init_struct.memory_inc_enable = TRUE;
    

  336.   dma_init_struct.peripheral_base_addr = (uint32_t)(&SPI2->dt);
    

  337.   dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
    

  338.   dma_init_struct.peripheral_inc_enable = FALSE;
    

  339.   dma_init_struct.priority = DMA_PRIORITY_VERY_HIGH;
    

  340.   dma_init_struct.loop_mode_enable = FALSE;
    

  341.   dma_init(DMA1_CHANNEL3, &dma_init_struct);
    


  342. 

  343.   spi_i2s_dma_transmitter_enable(SPI2, TRUE);
    

  344.   spi_i2s_dma_receiver_enable(SPI2, TRUE);
    


  345. 

  346.   dma_channel_enable(DMA1_CHANNEL2, TRUE);
    

  347.   dma_channel_enable(DMA1_CHANNEL3, TRUE);
    


  348. 

  349.   while(dma_flag_get(DMA1_FDT2_FLAG) == RESET);
    

  350.   dma_flag_clear(DMA1_FDT2_FLAG);
    


  351. 

  352.   dma_channel_enable(DMA1_CHANNEL2, FALSE);
    

  353.   dma_channel_enable(DMA1_CHANNEL3, FALSE);
    


  354. 

  355.   spi_i2s_dma_transmitter_enable(SPI2, FALSE);
    

  356.   spi_i2s_dma_receiver_enable(SPI2, FALSE);
    

  357. #else
    

  358.   while(length--)
    

  359.   {
    

  360.     while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET);
    

  361.     spi_i2s_data_transmit(SPI1, *pbuffer);
    

  362.     while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
    

  363.     dummy_data = spi_i2s_data_receive(SPI1);
    

  364.     pbuffer++;
    

  365.   }
    

  366. #endif
    

  367. }
    


  368. 

  369. /**
    

  370.   * @brief  read data continuously
    

  371.   * @param  pbuffer: buffer to save data
    

  372.   * @param  length: buffer length
    

  373.   * @retval none
    

  374.   */
    

  375. void spi_bytes_read(uint8_t *pbuffer, uint32_t length)
    

  376. {
    

  377.   uint8_t write_value = FLASH_SPI_DUMMY_BYTE;
    


  378. 

  379. #if defined(SPI_TRANS_DMA)
    

  380.   dma_init_type dma_init_struct;
    

  381.   dma_reset(DMA1_CHANNEL2);
    

  382.   dma_reset(DMA1_CHANNEL3);
    

  383.   
    

  384.   dma_flexible_config(DMA1, FLEX_CHANNEL2, DMA_FLEXIBLE_SPI2_RX);
    

  385.   dma_flexible_config(DMA1, FLEX_CHANNEL3, DMA_FLEXIBLE_SPI2_TX);
    

  386.   
    

  387.   dma_default_para_init(&dma_init_struct);
    

  388.   dma_init_struct.buffer_size = length;
    

  389.   dma_init_struct.direction = DMA_DIR_MEMORY_TO_PERIPHERAL;
    

  390.   dma_init_struct.memory_base_addr = (uint32_t)&write_value;
    

  391.   dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
    

  392.   dma_init_struct.memory_inc_enable = FALSE;
    

  393.   dma_init_struct.peripheral_base_addr = (uint32_t)(&SPI2->dt);
    

  394.   dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
    

  395.   dma_init_struct.peripheral_inc_enable = FALSE;
    

  396.   dma_init_struct.priority = DMA_PRIORITY_VERY_HIGH;
    

  397.   dma_init_struct.loop_mode_enable = FALSE;
    

  398.   dma_init(DMA1_CHANNEL3, &dma_init_struct);
    


  399. 

  400.   dma_init_struct.buffer_size = length;
    

  401.   dma_init_struct.direction = DMA_DIR_PERIPHERAL_TO_MEMORY;
    

  402.   dma_init_struct.memory_base_addr = (uint32_t)pbuffer;
    

  403.   dma_init_struct.memory_data_width = DMA_MEMORY_DATA_WIDTH_BYTE;
    

  404.   dma_init_struct.memory_inc_enable = TRUE;
    

  405.   dma_init_struct.peripheral_base_addr = (uint32_t)(&SPI2->dt);
    

  406.   dma_init_struct.peripheral_data_width = DMA_PERIPHERAL_DATA_WIDTH_BYTE;
    

  407.   dma_init_struct.peripheral_inc_enable = FALSE;
    

  408.   dma_init_struct.priority = DMA_PRIORITY_VERY_HIGH;
    

  409.   dma_init_struct.loop_mode_enable = FALSE;
    

  410.   dma_init(DMA1_CHANNEL2, &dma_init_struct);
    


  411. 

  412.   spi_i2s_dma_transmitter_enable(SPI2, TRUE);
    

  413.   spi_i2s_dma_receiver_enable(SPI2, TRUE);
    

  414.   dma_channel_enable(DMA1_CHANNEL2, TRUE);
    

  415.   dma_channel_enable(DMA1_CHANNEL3, TRUE);
    


  416. 

  417.   while(dma_flag_get(DMA1_FDT2_FLAG) == RESET);
    

  418.   dma_flag_clear(DMA1_FDT2_FLAG);
    


  419. 

  420.   dma_channel_enable(DMA1_CHANNEL2, FALSE);
    

  421.   dma_channel_enable(DMA1_CHANNEL3, FALSE);
    


  422. 

  423.   spi_i2s_dma_transmitter_enable(SPI2, FALSE);
    

  424.   spi_i2s_dma_receiver_enable(SPI2, FALSE);
    

  425. #else
    

  426.   while(length--)
    

  427.   {
    

  428.     while(spi_i2s_flag_get(SPI1, SPI_I2S_TDBE_FLAG) == RESET);
    

  429.     spi_i2s_data_transmit(SPI1, write_value);
    

  430.     while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
    

  431.     *pbuffer = spi_i2s_data_receive(SPI1);
    

  432.     pbuffer++;
    

  433.   }
    

  434. #endif
    

  435. }
    


  436. 

  437. /**
    

  438.   * @brief  wait program done
    

  439.   * @param  none
    

  440.   * @retval none
    

  441.   */
    

  442. void spiflash_wait_busy(void)
    

  443. {
    

  444.   while((spiflash_read_sr1() & 0x01) == 0x01);
    

  445. }
    


  446. 

  447. /**
    

  448.   * @brief  read sr1 register
    

  449.   * @param  none
    

  450.   * @retval none
    

  451.   */
    

  452. uint8_t spiflash_read_sr1(void)
    

  453. {
    

  454.   uint8_t breadbyte = 0;
    

  455.   FLASH_CS_LOW();
    

  456.   spi_byte_write(SPIF_READSTATUSREG1);
    

  457.   breadbyte = (uint8_t)spi_byte_read();
    

  458.   FLASH_CS_HIGH();
    

  459.   return (breadbyte);
    

  460. }
    


  461. 

  462. /**
    

  463.   * @brief  enable write operation
    

  464.   * @param  none
    

  465.   * @retval none
    

  466.   */
    

  467. void spiflash_write_enable(void)
    

  468. {
    

  469.   FLASH_CS_LOW();
    

  470.   spi_byte_write(SPIF_WRITEENABLE);
    

  471.   FLASH_CS_HIGH();
    

  472. }
    


  473. 

  474. /**
    

  475.   * @brief  read device id
    

  476.   * @param  none
    

  477.   * @retval device id
    

  478.   */
    

  479. uint16_t spiflash_read_id(void)
    

  480. {
    

  481.   uint16_t wreceivedata = 0;
    

  482.   FLASH_CS_LOW();
    

  483.   spi_byte_write(SPIF_MANUFACTDEVICEID);
    

  484.   spi_byte_write(0x00);
    

  485.   spi_byte_write(0x00);
    

  486.   spi_byte_write(0x00);
    

  487.   wreceivedata |= spi_byte_read() << 8;
    

  488.   wreceivedata |= spi_byte_read();
    

  489.   FLASH_CS_HIGH();
    

  490.   return wreceivedata;
    

  491. }
    


  492. 

  493. /**
    

  494.   * @brief  write a byte to flash
    

  495.   * @param  data: data to write
    

  496.   * @retval flash return data
    

  497.   */
    

  498. uint8_t spi_byte_write(uint8_t data)
    

  499. {
    

  500.   uint8_t brxbuff;
    

  501.   spi_i2s_dma_transmitter_enable(SPI1, FALSE);
    

  502.   spi_i2s_dma_receiver_enable(SPI1, FALSE);
    

  503.   spi_i2s_data_transmit(SPI1, data);
    

  504.   while(spi_i2s_flag_get(SPI1, SPI_I2S_RDBF_FLAG) == RESET);
    

  505.   brxbuff = spi_i2s_data_receive(SPI1);
    

  506.   while(spi_i2s_flag_get(SPI1, SPI_I2S_BF_FLAG) != RESET);
    

  507.   return brxbuff;
    

  508. }
    


  509. 

  510. /**
    

  511.   * @brief  read a byte to flash
    

  512.   * @param  none
    

  513.   * @retval flash return data
    

  514.   */
    

  515. uint8_t spi_byte_read(void)
    

  516. {
    

  517.   return (spi_byte_write(FLASH_SPI_DUMMY_BYTE));
    

  518. }
    


  519. 

  520. /**
    

  521.   * @}
    

  522.   */
    


  523. 

  524. /**
    

  525.   * @}
    

  526.   */
    


  527.


2.3、spi-flash.h
复制
  1. /**
    

  2.   **************************************************************************
    

  3.   * @file     spi_flash.h
    

  4.   * @brief    header file of spi_flash
    

  5.   **************************************************************************
    

  6.   *                       Copyright notice & Disclaimer
    

  7.   *
    

  8.   * The software Board Support Package (BSP) that is made available to
    

  9.   * download from Artery official website is the copyrighted work of Artery.
    

  10.   * Artery authorizes customers to use, copy, and distribute the BSP
    

  11.   * software and its related documentation for the purpose of design and
    

  12.   * development in conjunction with Artery microcontrollers. Use of the
    

  13.   * software is governed by this copyright notice and the following disclaimer.
    

  14.   *
    

  15.   * THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES,
    

  16.   * GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS,
    

  17.   * TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR
    

  18.   * STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS,
    

  19.   * INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
    

  20.   * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
    

  21.   *
    

  22.   **************************************************************************
    

  23.   */
    


  24. 

  25. #ifndef __SPI_FLASH_H
    

  26. #define __SPI_FLASH_H
    


  27. 

  28. #include "at32l021.h"
    


  29. 

  30. /** @addtogroup AT32L021_periph_examples
    

  31.   * @{
    

  32.   */
    


  33. 

  34. /** @addtogroup 021_SPI_w25q_flash
    

  35.   * @{
    

  36.   */
    


  37. 


  38. 

  39.  /* use dma transfer spi data */
    

  40. //#define SPI_TRANS_DMA
    


  41. 

  42. /** @defgroup SPI_flash_cs_pin_definition
    

  43.   * @{
    

  44.   */
    


  45. 

  46. #define FLASH_CS_HIGH()                  gpio_bits_set(GPIOA, GPIO_PINS_15)
    

  47. #define FLASH_CS_LOW()                   gpio_bits_reset(GPIOA, GPIO_PINS_15)
    


  48. 

  49. /**
    

  50.   * @}
    

  51.   */
    


  52. 

  53. /** @defgroup SPI_flash_id_definition
    

  54.   * @{
    

  55.   */
    


  56. 

  57. /*
    

  58.  * flash define
    

  59.  */
    

  60. #define W25Q80                           0xEF13
    

  61. #define W25Q16                           0xEF14
    

  62. #define W25Q32                           0xEF15
    

  63. #define W25Q64                           0xEF16
    

  64. /* 16mb, the range of address:0~0xFFFFFF */
    

  65. #define W25Q128                          0xEF17
    


  66. 

  67. /**
    

  68.   * @}
    

  69.   */
    


  70. 

  71. /** @defgroup SPI_flash_operation_definition
    

  72.   * @{
    

  73.   */
    


  74. 

  75. #define SPIF_CHIP_SIZE                   0x1000000
    

  76. #define SPIF_SECTOR_SIZE                 4096
    

  77. #define SPIF_PAGE_SIZE                   256
    


  78. 

  79. #define SPIF_WRITEENABLE                 0x06
    

  80. #define SPIF_WRITEDISABLE                0x04
    

  81. /* s7-s0 */
    

  82. #define SPIF_READSTATUSREG1              0x05
    

  83. #define SPIF_WRITESTATUSREG1             0x01
    

  84. /* s15-s8 */
    

  85. #define SPIF_READSTATUSREG2              0x35
    

  86. #define SPIF_WRITESTATUSREG2             0x31
    

  87. /* s23-s16 */
    

  88. #define SPIF_READSTATUSREG3              0x15
    

  89. #define SPIF_WRITESTATUSREG3             0x11
    

  90. #define SPIF_READDATA                    0x03
    

  91. #define SPIF_FASTREADDATA                0x0B
    

  92. #define SPIF_FASTREADDUAL                0x3B
    

  93. #define SPIF_PAGEPROGRAM                 0x02
    

  94. /* block size:64kb */
    

  95. #define SPIF_BLOCKERASE                  0xD8
    

  96. #define SPIF_SECTORERASE                 0x20
    

  97. #define SPIF_CHIPERASE                   0xC7
    

  98. #define SPIF_POWERDOWN                   0xB9
    

  99. #define SPIF_RELEASEPOWERDOWN            0xAB
    

  100. #define SPIF_DEVICEID                    0xAB
    

  101. #define SPIF_MANUFACTDEVICEID            0x90
    

  102. #define SPIF_JEDECDEVICEID               0x9F
    

  103. #define FLASH_SPI_DUMMY_BYTE             0xA5
    


  104. 

  105. /**
    

  106.   * @}
    

  107.   */
    


  108. 

  109. /** @defgroup SPI_flash_exported_functions
    

  110.   * @{
    

  111.   */
    


  112. 

  113. void spiflash_init(void);
    

  114. void spiflash_write(uint8_t *pbuffer, uint32_t write_addr, uint32_t length);
    

  115. void spiflash_read(uint8_t *pbuffer, uint32_t read_addr, uint32_t length);
    

  116. void spiflash_sector_erase(uint32_t erase_addr);
    

  117. void spiflash_write_nocheck(uint8_t *pbuffer, uint32_t write_addr, uint32_t length);
    

  118. void spiflash_page_write(uint8_t *pbuffer, uint32_t write_addr, uint32_t length);
    

  119. void spi_bytes_write(uint8_t *pbuffer, uint32_t length);
    

  120. void spi_bytes_read(uint8_t *pbuffer, uint32_t length);
    

  121. void spiflash_wait_busy(void);
    

  122. uint8_t spiflash_read_sr1(void);
    

  123. void spiflash_write_enable(void);
    

  124. uint16_t spiflash_read_id(void);
    

  125. uint8_t spi_byte_write(uint8_t data);
    

  126. uint8_t spi_byte_read(void);
    


  127. 

  128. /**
    

  129.   * @}
    

  130.   */
    


  131. 

  132. /**
    

  133.   * @}
    

  134.   */
    


  135. 

  136. /**
    

  137.   * @}
    

  138.   */
    


  139. 

  140. #endif
    


  141.


2.4、main.c
复制
  1. #include "at32l021_clock.h"
    

  2. #include "usart/usart.h"
    

  3. #include "led/led.h"
    

  4. #include "delay/delay.h"
    

  5. #include "i2c/i2c.h"
    

  6. #include "oled/oled.h"
    

  7. #include "adc/adc.h"
    

  8. #include "spiflash/spi_flash.h"
    


  9. 

  10. #define FLASH_TEST_ADDR                  0x1000
    

  11. #define SPI_BUF_SIZE                     256
    


  12. 

  13. uint8_t tx_buffer[SPI_BUF_SIZE];
    

  14. uint8_t rx_buffer[SPI_BUF_SIZE];
    


  15. 

  16. void tx_data_fill(void)
    

  17. {
    

  18.   uint32_t data_index = 0;
    

  19.   for(data_index = 0; data_index < SPI_BUF_SIZE; data_index++)
    

  20.   {
    

  21.     tx_buffer[data_index] = data_index;
    

  22.   }
    

  23. }
    


  24. 

  25. int main(void)
    

  26. {
    

  27.         __IO uint32_t index = 0;
    

  28.         __IO uint32_t flash_id_index = 0;
    

  29.   system_clock_config();
    

  30.         init_usart(115200); 
    

  31.         delay_init();
    

  32.         init_led();
    

  33.         printf("test\r\n");
    

  34.         tx_data_fill();
    

  35.         spiflash_init();
    

  36.         flash_id_index = spiflash_read_id();
    

  37.         if(flash_id_index !=0x5114)
    

  38.         {
    

  39.                 printf("flash id check error!\r\n");
    

  40.         }
    

  41.         else
    

  42.         {
    

  43.                 printf("flash id check success! id: %x\r\n", flash_id_index);
    

  44.         }
    

  45.         
    

  46.         spiflash_sector_erase(FLASH_TEST_ADDR / SPIF_SECTOR_SIZE);
    

  47.         spiflash_write(tx_buffer, FLASH_TEST_ADDR, SPI_BUF_SIZE);
    

  48.         spiflash_read(rx_buffer, FLASH_TEST_ADDR, SPI_BUF_SIZE);
    

  49.         printf("Read Data: ");
    

  50.   for(index = 0; index < SPI_BUF_SIZE; index++)
    

  51.   {
    

  52.     printf("%x ", rx_buffer[index]);
    

  53.   }
    

  54.         
    

  55.   while(1)
    

  56.   {
    

  57.     led2_tog();
    

  58.     delay_ms(200);
    

  59.   }
    

  60. }


三、运行结果

串口输出读出的数据
003.png

回复 赏

举报

相关帖子
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

tlled

132

主题

701

帖子

7

粉丝
快速回复 在线客服 返回列表 返回顶部