STM32G070xx将Flash页分块方式存储，固定数据块存储，实现一次擦除多次写入

原创 于 2025-05-08 14:30:36 发布 · 1.2k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#stm32 #嵌入式硬件 #单片机 #c语言 #51单片机

STM32G070xx将Flash页分块方式存储，固定数据块存储，实现一次擦除多次写入

参考例程



例程说明

  • 本例程使用STM32G070xx芯片，Flash大小128KB。第125~126KB为操作存储区，地址0x0801F000 ~ 0x0801F7FF每块32字节；第127~128KB为标定存储区，地址0x0801F800 ~ 0x0801FFFF每块128字节
  • Flash每页(2048字节)写满后再擦除。操作存储区分为64块,每块32字节,即写满64次擦除一次；标定存储区分为16块，每块128字节，即写满16次擦除一次
  • 每块读写都有校验。读取时校验不通过表示数据异常，往前继续读取数据，直到校验通过为止
  • 在写入Flash前。数据前后对比，只有数据发生变化才写入Flash中
  • 每个存储区的块都有各自的头部标记

一、存储区数据结构

在这里插入图片描述


#define FLASH_STORE_OPERAT_PARM_PAGE                         (125)
#define FLASH_STORE_OPERAT_PARM_START_ADDRE                  (0x0801F000UL)
#define FLASH_STORE_OPERAT_PARM_HEADER_TAG                   (0x2A3D)
#define FLASH_STORE_OPERAT_PARM_BLOCK_SIZE                   (32)
#define FLASH_STORE_OPERAT_PARM_BLOCK_COUNT                  (u16)(FLASH_PAGE_SIZE / FLASH_STORE_OPERAT_PARM_BLOCK_SIZE) //64

#define FLASH_STORE_DEMAR_PARM_PAGE                          (127)
#define FLASH_STORE_DEMAR_PARM_START_ADDRE                   (0x0801F800UL)
#define FLASH_STORE_DEMAR_PARM_HEADER_TAG                    (0x6C5A)
#define FLASH_STORE_DEMAR_PARM_BLOCK_SIZE                    (128)
#define FLASH_STORE_DEMAR_PARM_BLOCK_COUNT                   (u16)(FLASH_PAGE_SIZE / FLASH_STORE_DEMAR_PARM_BLOCK_SIZE) //16



#pragma pack(1)

typedef struct
{
    u16 HeaderTag;  /* 头部标记 */
    u16 StoreIndex; /* 存储索引 */
}FlashStoreHeader, * FlashStoreHeader_t;

typedef struct
{
    FlashStoreHeader  Header;
    ............ /* 用户定义数据1 */ 
    ............ /* 用户定义数据2 */ 

    u8 ubRes[23]; /* 块大小对齐 */
    u8 ubCRC8;    /* 校验和 */
}DemarParam_TypeDef, * DemarParam_TypeDef_t;

typedef struct
{
    FlashStoreHeader  Header;
    ............ /* 用户定义数据1 */ 
    ............ /* 用户定义数据2 */ 

    u8 ubRes[9]; /* 块大小对齐 */
    u8 ubCRC8;   /* 校验和 */
}OperatParam_TypeDef, * OperatParam_TypeDef_t;

typedef struct
{
    OperatParam_TypeDef Operat; /* 操作存储区 共32字节 */
    DemarParam_TypeDef  Demar;  /* 标定存储区 共128字节 */
}SystemParamStore_TypeDef, * SystemParamStore_TypeDef_t;

#pragma pack()



static SystemParamStore_TypeDef SystemStoreParam = {0};
DemarParam_TypeDef  * pStoreSysDemar  = &SystemStoreParam.Demar;
OperatParam_TypeDef * pStoreSysOperat = &SystemStoreParam.Operat;



二、读取存储区数据


static u16 usGet_Flash_Read_Index(u16 page)
{
    u32 startAddr  = FLASH_STORE_DEMAR_PARM_START_ADDRE;
    u16 blackSize  = FLASH_STORE_DEMAR_PARM_BLOCK_SIZE;
    u16 headerTag  = FLASH_STORE_DEMAR_PARM_HEADER_TAG;
    u8  blackCount = FLASH_STORE_DEMAR_PARM_BLOCK_COUNT;
    u8  len = XOFS(DemarParam_TypeDef , ubCRC8);
    u16 dat = 0, i = 0;
    u8  crc = 0;

    if (page == FLASH_STORE_OPERAT_PARM_PAGE)
    {
        startAddr  = FLASH_STORE_OPERAT_PARM_START_ADDRE;
        blackSize  = FLASH_STORE_OPERAT_PARM_BLOCK_SIZE;
        headerTag  = FLASH_STORE_OPERAT_PARM_HEADER_TAG;
        blackCount = FLASH_STORE_OPERAT_PARM_BLOCK_COUNT;
        len = XOFS(OperatParam_TypeDef , ubCRC8);
    }

    #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
    dprintf("R-startAddr:%X blackSize:%u headerTag:%X  blackCount:%u  len:%u\r\n", startAddr, blackSize, headerTag, blackCount, len);
    #endif

    for (i = 0; i < blackCount; ++i)
    {
        dat = *(volatile u16 *)(startAddr + ((blackCount - 1 - i) * blackSize));
        if (dat == headerTag)
        {
            crc = ubCheckSum_CRC8((void *)(startAddr + ((blackCount - 1 - i) * blackSize)), len);
            dat = *(volatile u8 *)(startAddr + ((blackCount - 1 - i) * blackSize) + (blackSize - 1));
            if (dat == crc)
            {
                return (blackCount - 1 - i);
            }
        }
    }

    return FLASH_STORE_OPERAT_PARM_BLOCK_COUNT;
}



static void vFixed_Operat_Value(void)
{
    SystemStoreParam.Operat.Header.HeaderTag = FLASH_STORE_OPERAT_PARM_HEADER_TAG;
}

static void vRestore_Operat_Parameter()
{
    memset((void *)(&SystemStoreParam.Operat), 0, sizeof(OperatParam_TypeDef));
    vFixed_Operat_Value();
}

static void vRead_Operat_Parameter(void)
{
    u16 index = usGet_Flash_Read_Index(FLASH_STORE_OPERAT_PARM_PAGE);
    if (index < FLASH_STORE_OPERAT_PARM_BLOCK_COUNT)
    {
        vFlash_Read_DoubleWord(FLASH_STORE_OPERAT_PARM_START_ADDRE + (FLASH_STORE_OPERAT_PARM_BLOCK_SIZE * index), (u64 *)(&SystemStoreParam.Operat), (FLASH_STORE_OPERAT_PARM_BLOCK_SIZE >> 3));
        vFixed_Operat_Value();

        #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
        dprintf("Read Operat Param OK...%u\r\n", SystemStoreParam.Operat.Header.StoreIndex);
        #endif
    }
    else
    {
        vRestore_Operat_Parameter();

        #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
        dprintf("Restore Operat Param...%u\r\n", SystemStoreParam.Operat.Header.StoreIndex);
        #endif
    }


    #if 1
    dprintf("--------------------- Operat Param Info ---------------------\r\n");
    dprintf("            00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F  \r\n");
    dprintf("-------------------------------------------------------------\r\n");
    for (index = 0; index < FLASH_STORE_OPERAT_PARM_BLOCK_SIZE; ++index)
    {
        if (index && (index % 16 == 0)) dprintf("\r\n");
        if (index % 16 == 0) dprintf("0x%08X  ", (FLASH_STORE_OPERAT_PARM_START_ADDRE + (FLASH_STORE_OPERAT_PARM_BLOCK_SIZE * SystemStoreParam.Operat.Header.StoreIndex) + index));
        dprintf("%02X ", *(volatile u8 *)(FLASH_STORE_OPERAT_PARM_START_ADDRE + (FLASH_STORE_OPERAT_PARM_BLOCK_SIZE * SystemStoreParam.Operat.Header.StoreIndex) + index));
    }
    dprintf("\r\n");
    dprintf("-------------------------------------------------------------\r\n");
    dprintf("\r\n\r\n");
    #endif
}






static void vFixed_Demar_Value(void)
{
    SystemStoreParam.Demar.Header.HeaderTag = FLASH_STORE_DEMAR_PARM_HEADER_TAG;
}

static void vRestore_Demar_Parameter(void)
{
    memset((void *)(&SystemStoreParam.Demar), 0, sizeof(DemarParam_TypeDef));
    vFixed_Demar_Value();
}

static void vRead_Demar_Parameter(void)
{
    u16 index = usGet_Flash_Read_Index(FLASH_STORE_DEMAR_PARM_PAGE);
    if (index < FLASH_STORE_DEMAR_PARM_BLOCK_COUNT)
    {
        vFlash_Read_DoubleWord(FLASH_STORE_DEMAR_PARM_START_ADDRE + (FLASH_STORE_DEMAR_PARM_BLOCK_SIZE * index), (u64 *)(&SystemStoreParam.Demar), (FLASH_STORE_DEMAR_PARM_BLOCK_SIZE >> 3));
        vFixed_Demar_Value();

        #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
        dprintf("Read Demar Param OK...%u\r\n", SystemStoreParam.Demar.Header.StoreIndex);
        #endif
    }
    else
    {
        vRestore_Demar_Parameter();

        #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
        dprintf("Restore Demar Param...%u\r\n", SystemStoreParam.Demar.Header.StoreIndex);
        #endif
    }


    #if 1
    dprintf("--------------------- Demar Param Info ----------------------\r\n");
    dprintf("            00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F  \r\n");
    dprintf("-------------------------------------------------------------\r\n");
    for (index = 0; index < FLASH_STORE_DEMAR_PARM_BLOCK_SIZE; ++index)
    {
        if (index && (index % 16 == 0)) dprintf("\r\n");
        if (index % 16 == 0) dprintf("0x%08X  ", (FLASH_STORE_DEMAR_PARM_START_ADDRE + (FLASH_STORE_DEMAR_PARM_BLOCK_SIZE * SystemStoreParam.Demar.Header.StoreIndex) + index));
        dprintf("%02X ", *(volatile u8 *)(FLASH_STORE_DEMAR_PARM_START_ADDRE + (FLASH_STORE_DEMAR_PARM_BLOCK_SIZE * SystemStoreParam.Demar.Header.StoreIndex) + index));
    }
    dprintf("\r\n");
    dprintf("-------------------------------------------------------------\r\n");
    dprintf("\r\n\r\n");
    #endif
}


static void vRead_GlobalSystem_Parameter(void)
{
    vRead_Operat_Parameter();
    vRead_Demar_Parameter();
}

void vRead_System_Parameter(void)
{
    #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
    dprintf("OperatParam_TypeDef Size: %u\r\n", sizeof(OperatParam_TypeDef));
    dprintf("DemarParam_TypeDef  Size: %u\r\n", sizeof(DemarParam_TypeDef));

    if (sizeof(OperatParam_TypeDef) != FLASH_STORE_OPERAT_PARM_BLOCK_SIZE)
    {
        dprintf("Operat Param Size Error......\r\n");
        while (1);
    }

    if (sizeof(DemarParam_TypeDef) != FLASH_STORE_DEMAR_PARM_BLOCK_SIZE)
    {
        dprintf("Demar Param Size Error......\r\n");
        while (1);
    }
    #endif

    pStoreSysDemar  = &SystemStoreParam.Demar;
    pStoreSysOperat = &SystemStoreParam.Operat;
    vRead_GlobalSystem_Parameter();
}



三、写入存储区数据


static u16 usGet_Flash_Write_Index(u16 page)
{
    u32 startAddr  = FLASH_STORE_DEMAR_PARM_START_ADDRE;
    u16 blackSize  = FLASH_STORE_DEMAR_PARM_BLOCK_SIZE;
    u8  blackCount = FLASH_STORE_DEMAR_PARM_BLOCK_COUNT;
    u16 dat = 0, i = 0, x = 0;
    u8  tmp = 0, uFlg = 0;

    if (page == FLASH_STORE_OPERAT_PARM_PAGE)
    {
        startAddr  = FLASH_STORE_OPERAT_PARM_START_ADDRE;
        blackSize  = FLASH_STORE_OPERAT_PARM_BLOCK_SIZE;
        blackCount = FLASH_STORE_OPERAT_PARM_BLOCK_COUNT;
    }

    #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
    dprintf("W-startAddr:%X blackSize:%u blackCount:%u\r\n", startAddr, blackSize, blackCount);
    #endif

    for (i = 0; i < blackCount; ++i)
    {
        dat = *(volatile u16 *)(startAddr + (blackSize * i));
        if (dat == 0xFFFFU)
        {
            uFlg = 0;
            for (x = 0; x < blackSize; ++x)
            {
                tmp = *(volatile u8 *)(startAddr + (blackSize * i) + x);
                if (tmp != 0xFFU)
                {
                    uFlg = 1;
                    break;
                }
            }

            if (!uFlg) 
            {
                return i;
            }
        }
    }

    return FLASH_STORE_OPERAT_PARM_BLOCK_COUNT;
}






static void vSave_System_Parameter(u16 page)
{
    u32 startAddr   = FLASH_STORE_DEMAR_PARM_START_ADDRE;
    u16 blackSize   = FLASH_STORE_DEMAR_PARM_BLOCK_SIZE;
    u8  blackCount  = FLASH_STORE_DEMAR_PARM_BLOCK_COUNT;
    u16 StoreIndex  = SystemStoreParam.Demar.Header.StoreIndex;
    u64 * pSaveDest = (u64 *)(&SystemStoreParam.Demar);
    u8  * pSrc      = (u8 *)(&SystemStoreParam.Demar);
    u8   mode = 0, dat = 0;
    u16  index = 0;


    if (page == FLASH_STORE_OPERAT_PARM_PAGE)
    {
        startAddr  = FLASH_STORE_OPERAT_PARM_START_ADDRE;
        blackSize  = FLASH_STORE_OPERAT_PARM_BLOCK_SIZE;
        blackCount = FLASH_STORE_OPERAT_PARM_BLOCK_COUNT;
        StoreIndex = SystemStoreParam.Operat.Header.StoreIndex;
        pSaveDest  = (u64 *)(&SystemStoreParam.Operat);
        pSrc       = (u8 *)(&SystemStoreParam.Operat);
    }

    for (index = 0; index < blackSize; ++index)
    {
        dat = *(volatile u8 *)(startAddr + (blackSize * StoreIndex) + index);
        if (dat != *pSrc++)
        {
            mode = 1;
            break;
        }
    }

    if (!mode)
    {
        #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
        dprintf("Save Pram Same......Index:%02u  Page:%u\r\n", StoreIndex, page);
        #endif

        return;
    }

    mode  = 0;
    index = usGet_Flash_Write_Index(page);
    if (index >= blackCount)
    {
        index = 0; 
        mode  = 1;
    }

    if (page == FLASH_STORE_DEMAR_PARM_PAGE) 
    {
        SystemStoreParam.Demar.Header.StoreIndex = index;
        SystemStoreParam.Demar.ubCRC8  = ubCheckSum_CRC8((void *)(&SystemStoreParam.Demar),  XOFS(DemarParam_TypeDef , ubCRC8));
    }
    else
    {
        SystemStoreParam.Operat.Header.StoreIndex = index;
        SystemStoreParam.Operat.ubCRC8 = ubCheckSum_CRC8((void *)(&SystemStoreParam.Operat), XOFS(OperatParam_TypeDef, ubCRC8));
    }
    
    if (ubFlash_Write_DoubleWord_EreasePage((startAddr + (blackSize * index)), pSaveDest, (blackSize >> 3), mode))
    {
        #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
        dprintf("Save Pram Error...%u\r\n", index);
        #endif
    }
    else
    {
        #if defined(DEBUG_RELEASE_VERSION_ENABLE) && (DEBUG_RELEASE_VERSION_ENABLE == 0)
        dprintf("Save Pram OK...%u  CRC-Demar:%02X  Operat:%02X\r\n", index, SystemStoreParam.Demar.ubCRC8, SystemStoreParam.Operat.ubCRC8);
        #endif
    }
}





static void vSynSave_Demar_Parameter(void)
{
}
void vSave_Demar_Parameter(void)
{
    vSynSave_Demar_Parameter();
    vSave_System_Parameter(FLASH_STORE_DEMAR_PARM_PAGE);
}


static void vSynSave_Operat_Parameter(void)
{
}
void vSave_Operat_Parameter(void)
{
    vSynSave_Operat_Parameter();
    vSave_System_Parameter(FLASH_STORE_OPERAT_PARM_PAGE);
}



四、测试函数

  • 读取数据:
    void vRead_System_Parameter(void); //读取数据 操作存储区+标定存储区


  • 保存数据：
    void vSave_Operat_Parameter(void); //操作存储区
    void vSave_Demar_Parameter(void); //标定存储区



五、测试结果

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

解决STM32 烧录程序后无法在内部FLASH保存数据问题
weixin_44597885的博客
11-06 602
FLASH设定后，存储数据断电数据不会丢失，重新烧录程序后数据就会丢失，解决过程如下。
STM32G0xx使用LL库将Flash页分块方式存储数据实现一次擦除可多次写入
RaphaelCeo的博客
11-04 1105
STM32G0xx使用LL库将Flash页分块方式存储数据实现一次擦除可多次写入
STM32G0系列将内部FLASH作为EEPROM使用，巧妙编程，可延长Flash擦写寿命上百倍，已用于量产产品。
weixin_42401119的博客
01-07 8560
STM32G0内部flash可以用作EEPROM，用于保存用户数据。 延长擦写寿命，已量产代码。
STM32G0x0单片机参考手册.pdf
12-19
This reference manual complements the datasheets of the STM32G0x0 microcontrollers, providing information required for application and in particular for software development. It pertains to the superset of feature sets available on STM32G0x0 microcontrollers
STM32G070进行flash读写操作
热门推荐
FreezeChen的专栏
10-25 1万+
STM32G070 flash读写问题 STM32G070xx的flash分布如下图，打算将Page 63用于保存用户数据。 问题 开始一直出现flash写入失败，从返回码来看是FLASH_FLAG_PGSERR，一直找不到原因，代码如下： #define ADDR_USER_DATA 0x0801F800 HAL_FLASH_Unlock(); FLASH_PageErase(63); r...
STM32G0xx HAL和LL库Flash读写擦除操作
RaphaelCeo的博客
10-11 5559
STM32G0xx HAL和LL库Flash读写擦除操作
STM32G0-内部flash读写驱动[寄存器版]
staypt的博客
12-26 5178
首先给出一个STM32G030芯片的闪存结构图：STM32G0的闪存模块由于Main memory(主储存器)，information block(信息块)两个部分组成。Main memory(主储存器)：用于储存用户编译烧录的代码和数据常量。information block(信息块)：信息块同样被分为了好几个部分：system memory(系统内存)OTP area(OTP 区域)Engineering bytes(工程字节)Option bytes(选项字节)
实现一个STM32G4单片机实现内部FLASH连续写入任意长度数据的函数
最新发布
03-15
在STM32G4上实现FLASH连续写入任意长度数据需结合地址管理、页擦除策略及哈希校验。以下是关键步骤及示例代码框架： ### 一、FLASH连续写入核心逻辑 1. **FLASH特性说明** - STM32G4 FLASH页大小为2KB，写操作前...
STM32 flash epprom 将数据保存在STM32中，掉电也保存
02-05
5. 为了防止意外的电源中断，写操作通常会采用双缓冲技术，先将新数据写入临时位置，待全部操作完成后才更新实际存储位置。 在给定的文件中，"USER"目录可能包含了实现这个功能的用户代码。"STM32F10x_FWLib"库可能...
AN4061_在STM32F0xx中用Flash模拟EEPROM，说明文档和例程
08-28
分块管理意味着我们将Flash划分为多个逻辑块，每个块对应于虚拟EEPROM的一部分。写入计数器则用于跟踪某个位置的写入次数，达到一定次数后，就需要移动到新的块进行写入，同时保留旧的数据，以便在下一次擦除前进行...
STM32G070 IAP HAL 库 在线升级
yuhu0012的博客
03-12 2436
在这之前写了STM32G070 hal Flash读写操作。在这个基础上，做个IAP在线升级。IAP升级方法有多种：1、双APP内存法：创建两个APP内存，一个升级，一个运行；2、BootLoader引导法：当程序升级时候，跳转到BootLoader去，进行升级。下面介绍双APP内存法，BootLoader引导法后面在写。提示：下面代码需要引用#include “./BSP/STMFLASH/stmflash.h”，在我上一个文章里面,连接。
STM32 FLASH 的读写保护
04-22 1354
如果用到STM32 IAP更新固件方式，我们可以给Boot loader区域进行FLASH 写保护，升级APP固件时，避免写地址错误而覆盖Bootlaoder区域。2、打开STM32 ST-LINK Utility软件，点击 Connect to the target图标。通过上述步骤，然后烧写保护区域的Flash固件，都会提示报错，这样保护了Bootloader底层软件不被破坏。3、选择要写保护的页面，然后点击Apply。1、用ST-LINK烧录工具连接单片机。
YoungTalk-STM32入门100步-FLASH读写与蜂鸣器操作（30-32）
猪猪的博客
07-30 766
目录 一、FLASH读写操作 二、蜂鸣器驱动程序以及MIDI音乐播放 《杀死那个石家庄人》 一、FLASH读写操作 #include "stm32f10x.h" //STM32头文件 #include "sys.h" #include "delay.h" #include "led.h" #include "key.h" #include "flash.h" #define FLASH_START_ADDR 0x0801f000 //写入的起始地址 int mai.
STM32G0系列的Flash标志位PGSERR和PGAERR上电置位
自由的天空
04-07 6797
此篇博客主要讲解STM32G0系列的Flash操作，没啥技术含量，老鸟直接发过就好了。 首先将Flash怎么操作，然后再讲标题中的问题及解决思路。 一、Flash操作 我建议大家先看编程手册的Flash这章，等有一个操作Flash的大概的流程概念(不需要 记住所有的操作步骤，因为有库)，再去看库操作历程(这是我个人的习惯，只是给大家 提个建议)。 1、首先来看Flash基本知识 ...
STM32G0 按照8位16位的方式写入flash HAL库
KyleKuang的博客
03-21 4020
由于STM32G0只能按照64位的方式写入flash，所以有时候需要保存8位或者16位的数组就不是很方便，所以我做了一个将8位或者16位的数组先拼接成64位再写入flash的函数。
keil For ARM 函数绝对定义
冷饮
06-27 2378
我写了一个函数，我要把它放到FLASH 的第31区，地址为0x0801F000 这个地方，我在网上搜了一个方法。 虽然达到了效果网上说加个__at;且包含头文件#include "absacc.h" 这种方法只适用于 数组的绝对定义。方法如下： u8 TestBUF[8]  __at(0x0801F000 )={0X34,0X66,0X03,0X34,0X23,0X77,0X77,0X77}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值