GD32F103读写内部FLASH

古城微笑少年丶 2022-09-08 13:51 659阅读 0赞

# GD32F103读写内部FLASH #

--------------------

**测试环境：**

*  STM32F103C8
 *  20KBytes RAM
 *  64KBytes FLASH

--------------------

![30d0eb54199a4070970b0f09104896b2.png][]  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAeS16aGVuZw_size_34_color_FFFFFF_t_70_g_se_x_16][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAeS16aGVuZw_size_34_color_FFFFFF_t_70_g_se_x_16 1][]

### 头文件 ###

/** * @brief Create by AnKun on 2019/10/10 */
    
    
    #ifndef GDFLASH_H__
    #define GDFLASH_H__
    
    #include "gd32f10x.h"
    
    /// 移植修改区 ///
    
    /* FLASH大小：64K */
    #define GD32FLASH_SIZE 0X00010000UL
    
    /* FLASH起始地址 */
    #define GD32FLASH_BASE FLASH_BASE
    
    /* FLASH结束地址 */
    #define GD32FLASH_END (GD32FLASH_BASE | GD32FLASH_SIZE)
    
    /* FLASH页大小：1K */
    #define GD32FLASH_PAGE_SIZE (1024U)
    
    /* FLASH总页数 */
    #define GD32FLASH_PAGE_NUM (GD32FLASH_SIZE / GD32FLASH_PAGE_SIZE)
    
    /// 导出函数声明 
    void FLASH_Init(void);
    uint32_t FLASH_Read(uint32_t Address, void *Buffer, uint32_t Size);
    uint32_t FLASH_Write(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite);
    int FLASH_ErasePage(uint32_t PageAddress, uint32_t NbPages);
    uint32_t FLASH_WriteNotErase(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite);
    
    #endif // !GDFLASH_H__

### 源文件 ###

/** * @file flash.c * * @brief Create by AnKun on 2019/10/10 * */
    
    #include "gdflash.h"
    #include <string.h>
    
    __align(4) static uint16_t FlashBuffer[GD32FLASH_PAGE_SIZE >> 1];
    
    /// 初始化FLASH
    void FLASH_Init(void)
    { 
    	fmc_unlock();
        fmc_flag_clear(FMC_FLAG_BANK0_END);
        fmc_flag_clear(FMC_FLAG_BANK0_WPERR);
        fmc_flag_clear(FMC_FLAG_BANK0_PGERR);
    	fmc_lock();
    }
    
    /** * 读FLASH * @param Address 地址 * @param Buffer 存放读取的数据 * @param Size 要读取的数据大小，单位字节 * @return 读出成功的字节数 */
    uint32_t FLASH_Read(uint32_t Address, void *Buffer, uint32_t Size)
    { 
        uint32_t nread = Size;
        uint8_t* d = (uint8_t *)Buffer;
        const uint8_t* s = (const uint8_t *)Address;
    
        if (!Buffer || Address < GD32FLASH_BASE || Address >= GD32FLASH_END)
            return 0;
    
        while (nread >= sizeof(uint32_t) && (((uint32_t)s) <= (GD32FLASH_END - 4)))
        { 
            *(volatile uint32_t *)d = *(volatile uint32_t *)s;
            d += sizeof(uint32_t);
            s += sizeof(uint32_t);
            nread -= sizeof(uint32_t);
        }
    
        while (nread && (((uint32_t)s) < GD32FLASH_END))
        { 
            *d++ = *s++;
            nread--;
        }
    
        return Size - nread;
    }
    
    /** * 写FLASH * @param Address 写入起始地址，！！！要求2字节对齐！！！ * @param Buffer 待写入的数据，！！！要求2字节对齐！！！ * @param NumToWrite 要写入的数据量，单位：半字，！！！要求2字节对齐！！！ * @return 实际写入的数据量，单位：字节 */
    uint32_t FLASH_Write(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite)
    { 
        uint32_t i = 0;
        uint32_t pagepos = 0;         // 页位置
        uint32_t pageoff = 0;         // 页内偏移地址
        uint32_t pagefre = 0;         // 页内空余空间
        uint32_t offset = 0;          // Address在FLASH中的偏移
        uint32_t nwrite = NumToWrite; // 记录剩余要写入的数据量
        const uint16_t *pBuffer = (const uint16_t *)Buffer;
    
        /* 非法地址 */
        if (Address < GD32FLASH_BASE || Address > (GD32FLASH_END - 2) || NumToWrite == 0 || pBuffer == NULL)
            return 0;
    
        /* 解锁FLASH */
        fmc_unlock();
    
        /* 计算偏移地址 */
        offset = Address - GD32FLASH_BASE;
    
        /* 计算当前页位置 */
        pagepos = offset / GD32FLASH_PAGE_SIZE;
    
        /* 计算要写数据的起始地址在当前页内的偏移地址 */
        pageoff = ((offset % GD32FLASH_PAGE_SIZE) >> 1);
    
        /* 计算当前页内空余空间 */
        pagefre = ((GD32FLASH_PAGE_SIZE >> 1) - pageoff);
    
        /* 要写入的数据量低于当前页空余量 */
        if (nwrite <= pagefre)
            pagefre = nwrite;
    
        while (nwrite != 0)
        { 
            /* 检查是否超页 */
            if (pagepos >= GD32FLASH_PAGE_NUM)
                break;
    
            /* 读取一页 */
            FLASH_Read(GD32FLASH_BASE + pagepos * GD32FLASH_PAGE_SIZE, FlashBuffer, GD32FLASH_PAGE_SIZE);
    
            /* 检查是否需要擦除 */
            for (i = 0; i < pagefre; i++)
            { 
                if (*(FlashBuffer + pageoff + i) != 0xFFFF) /* FLASH擦出后默认内容全为0xFF */
                    break;
            }
    
            if (i < pagefre)
            { 
                uint32_t count = 0;
                uint32_t index = 0;
    
    			if(FLASH_ErasePage(pagepos * GD32FLASH_PAGE_SIZE, 1) < 0)
    				break;
    
                /* 复制到缓存 */
                for (index = 0; index < pagefre; index++)
                { 
                    *(FlashBuffer + pageoff + index) = *(pBuffer + index);
                }
    
                /* 写回FLASH */
                count = FLASH_WriteNotErase(GD32FLASH_BASE + pagepos * GD32FLASH_PAGE_SIZE, FlashBuffer, GD32FLASH_PAGE_SIZE >> 1);
                if (count != (GD32FLASH_PAGE_SIZE >> 1))
                { 
                    nwrite -= count;
                    break;
                }
            }
            else
            { 
                /* 无需擦除，直接写 */
                uint32_t count = FLASH_WriteNotErase(Address, pBuffer, pagefre);
                if (count != pagefre)
                { 
                    nwrite -= count;
                    break;
                }
            }
    
            pBuffer += pagefre;         /* 读取地址递增 */
            Address += (pagefre << 1);  /* 写入地址递增 */
            nwrite -= pagefre;          /* 更新剩余未写入数据量 */
    
            pagepos++;     /* 下一页 */
            pageoff = 0;   /* 页内偏移地址置零 */
    
            /* 根据剩余量计算下次写入数据量 */
            pagefre = nwrite >= (GD32FLASH_PAGE_SIZE >> 1) ? (GD32FLASH_PAGE_SIZE >> 1) : nwrite;
        }
    
        /* 加锁FLASH */
        fmc_unlock();
    
        return ((NumToWrite - nwrite) << 1);
    }
    
    uint32_t FLASH_WriteNotErase(uint32_t Address, const uint16_t *Buffer, uint32_t NumToWrite)
    { 
        uint32_t nwrite = NumToWrite;
        uint32_t addrmax = GD32FLASH_END - 2;
    
        while (nwrite)
        { 
            if (Address > addrmax)
                break;
    
    		fmc_halfword_program(Address, *Buffer);
    		
            if ((*(__IO uint16_t*) Address) != *Buffer)
                break;
    
            nwrite--;
            Buffer++;
            Address += 2;
        }
        return (NumToWrite - nwrite);
    }
    
    int FLASH_ErasePage(uint32_t PageAddress, uint32_t NbPages)
    { 
    	while(NbPages--)
    	{ 
    		if(fmc_page_erase(PageAddress) != FMC_READY)
    		{ 
    			return -1;
    		}
    		PageAddress += GD32FLASH_PAGE_SIZE;
    	}
    	return 0;
    }

--------------------

ends…

[30d0eb54199a4070970b0f09104896b2.png]: /images/20220829/5466621dcd244f1f9bbcffb8340887c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAeS16aGVuZw_size_34_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/816ea7697fd84676945861b862069967.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAeS16aGVuZw_size_34_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/9032f3a000a84cbe9913603ea9ac9fab.png