FFT的汇编

已于 2022-04-01 20:11:50 修改
阅读量707 收藏 1
点赞数 1
分类专栏： 信号处理 文章标签： dsp开发 单片机 傅里叶分析 硬件工程 嵌入式实时数据库
于 2022-03-26 20:24:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46092376/article/details/123762227
版权

汇编语言的FFT

C语言的FFT在单片机系统运行效率低。汇编会大大提高速度

定点DSP，C28x定点库，

此版本包含TI定点库的FFT和滤波器模块。其他模块可能会在未来的版本中添加。FFT、FIR和IIR类别下的函数是为每个模块定义的结构的成员函数，应该通过结构对象调用，而不是直接调用函数。位反转函数是个例外，它只能直接调用。默认宏用于帮助用户初始化模块对象，并确保将正确的值写入对象的每个元素。这一点很重要，尤其是在复杂和真实FFT模块的情况下。它们都使用复数FFT函数FFT32_calc（），不同之处在于，N点实FFT是通过运行N/2点复数FFT，然后执行拆分操作来完成的。因此，用户必须用正确的FFT大小、旋转因子跳过率和级数实例化RFFT对象。使用初始化宏可以使任务简单无误。下表列出了功能及其原型：在这里插入图片描述

实数FFT

// An highlighted block
; DESCRIPTION:
;
;    This function computes a real FFT.  The input buffer must be aligned to
;    a multiple of the FFT size.  If it is not aligned then the output buffer
;    will yield invalid results.  If you do not wish to align the input buffer
;    then use the RFFT_f32u function.  Using this function will reduce cycle
;    performance of the algorithm.
;
; FUNCTIONS:
;
;    void RFFT_f32 (FFT_REAL *)
;    void RFFT_f32_mag (FFT_REAL *)
;    void RFFT_f32_phase (FFT_REAL *)
;
;    Where RFFT_F32_STRUCT is a structure defined as:
;
;    typedef struct {
   
;      float32  *InBuf;
;      float32  *OutBuf;
;      float32  *CosSinBuf;
;      float32  *MagBuf;
;      float32  *PhaseBuf;
;      Uint16 FFTSize;
;      Uint16 FFTStages;
;    } RFFT_F32_STRUCT;
;
; ASSUMPTIONS:
;
;     * FFTSize must be a power of 2 (32, 64, 128, etc)
;     * FFTSize must be greater or equal to 32
;     * FFTStages must be log2(FFTSize)
;     * InBuf, OutBuf, CosSinBuf are FFTSize in length
;     * MagBuf and PhaseBuf are FFTSize/2 in length
;     * MagBuf and PhaseBuf are not used by this function.
;       They are only used by the magitude and phase calculation functions.
;
; ALGORITHUM:
;
; 1) Bit reverse input data and calculate stages 1, 2 & 3:
;
;  In Buf (read in bit reverse order)                             Out Buf
;  +----+                                                          +----+
;  | I1 | (((I1 + I2) + (I3 + I4)) + ((I5 + I6) + (I7 + I8)))/8 -> | I1'|
;  | I2 | ((I1 - I2) + COS*((I5 - I6) + (I8 - I7))          )/8 -> | I2'|
;  | I3 | ((I1 + I2) - (I3 + I4)                            )/8 -> | I3'|
;  | I4 | ((I1 - I2) - COS*((I5 - I6) + (I8 - I7))          )/8 -> | I4'|
;  | I5 | (((I1 + I2) + (I3 + I4)) - ((I5 + I6) + (I7 + I8)))/8 -> | I5'|
;  | I6 | (COS*((I8 - I7) - (I5 - I6)) - (I4 - I3)          )/8 -> | I6'|
;  | I7 | ((I7 + I8) - (I5 + I6)                            )/8 -> | I7'|
;  | I8 | (COS*((I8 - I7) - (I5 - I6)) + (I4 - I3)          )/8 -> | I8'|
;     .
;     .
;    \|/
; Repeat above FFTSize/8 (i.e. if FFTSize = 1024, Repeat = 128 times)
;
; Note: COS = COS( 1*2*PI/8) = SIN( 1*2*PI/8)
;
; 2) Calculate stages 4 and up:
;
;
;             Out Buf   4   5   6   7   8   9   10  <- Stages
; +-        +---------+ -   -   -   -   -   -   --
; |         |    Y1   | 0   0   0   0   0   0    0  <-   Y1 + Y3
; |         |---------|
; |         |  X(I1)  | 1   1   1   1   1   1    1  <-   X(I1) + [X(I3)*COS + X(I4)*SIN]
; |         |---------|
; |         |    .    |
; |         |    .    | 3   7  15  31  63 127  255  <-   Inner Loop Repeat Times
; |         |   \./   |
; |  I      |---------|
; |  N      |    Y2   | 4   8  16  32  64 128  256  <-   Y2
; |  N      |---------|
; |  E      |   /.\   |
; |  R      |    .    |
; |         |    .    |
; |  L      |---------|
; |  O      |  X(I2)  | 7  15  31  63 127 255  511 <-   X(I1) - [X(I3)*COS + X(I4)*SIN]
; |  O      |---------|
; |  P      |    Y3   | 8  16  32  64 128 256  512 <-   Y1 - Y3
; |         |---------|
; |         |  X(I3)  | 9  17  33  65 129 257  513 <-   [X(I4)*COS - X(I3)*SIN] - X(I2)
; |         |---------|
; |         |    .    |
; |         |    .    |
; |         |   \./   |
; |         |---------|
; |         |    Y4   |12  24  48  96 192 384  768 <-   -Y4
; |         |---------|
; |         |   /.\   |
; |         |    .    |
; |         |    .    |
; |         |---------|
; |         |  X(I4)  |15  31  63 127 255 511 1023 <-   [X(I4)*COS - X(I3)*SIN] + X(I2)
; +-        |---------|
;           |         |16  32  64 128 256 512 1024
;                      -- --- --- --- --- --- ----
;                .      1                          <-   Outer Loop Repeat Times (16   FFT)
;                .      2   1                      <-   Outer Loop Repeat Times (32   FFT)
;                .      4   2   1                  <-   Outer Loop Repeat Times (64   FFT)
;                .      8   4   2   1              <-   Outer Loop Repeat Times (128  FFT)
;                .     16   8   4   2   1          <-   Outer Loop Repeat Times (256  FFT)
;                .     32  16   8   4   2   1      <-   Outer Loop Repeat Times (512  FFT)
;                .     64  32  16   8   4   2    1 <-   Outer Loop Repeat Times (1024 FFT)
;                .
;                .
;               \|/
; ###########################################################################
; $TI Release: C28x Floating Point Unit Library V1.31 $
; $Release Date: Sep 10, 2012 $
; ###########################################################################


;===========================================================================
; Function: void RFFT_f32(FFT_REAL *fft)
;===========================================================================
; RFFT_f32_Stages1and2and3andBitReverse(RFFT_F32_STRUCT *);
; RFFT_f32_Stages4andUp(RFFT_F32_STRUCT *);
;
       .global      _RFFT_f32
       .sect       .text

_RFFT_f32:
       ADDB SP,#2
       MOVL *-SP[2],XAR4
       LCR  _rfft_f32_Stages1and2and3andBitReverse
       MOVL XAR4,*-SP[2]
       LCR  _rfft_f32_Stages4andUp
       SUBB SP,#2
       LRETR

;===========================================================================
; Function: void rfft_f32_Stages1and2and3andBitReverse(RFFT_F32_STRUCT *rfft)
;===========================================================================
;---------------------------------------------------------------------------
;
; DESCRIPTION:
;
;     This function bit reverses the input and computes stages 1, 2 and 3
;
; ON ENTRY:
;
;     XAR4 = Starting address of the RFFT_F32_STRUCT structure
;
; REGISTER USAGE:
;
;     AR0, XAR1, XAR2, XAR4, XAR5, AR3, AR6, XAR7, ACC,
;     R0H, R1H, R2H, R3H, R4H, R5H, R6H, R7H
;
; On Exit:
;
;     RFFT_F32_STRUCT OutBuf contains the computed result
;
;---------------------------------------------------------------------------
;offsets to the stack which holds the bit reversed elements
;---------------------------------------------------------------------------

I1         .set 06H
I2         .set 08H
I3         .set 0AH
I4         .set 0CH
I5         .set 0EH
I6         .set 10H
I7         .set 12H
I8         .set 14H
cossinBuf  .set 04H
;--------------------------------------------------------------------------------
;Offset to the stack which holds intermediate results of FFT computation
;-------------------------------------------------------------------------------
           .global  _rfft_f32_Stages1and2and3andBitReverse
           .text

_rfft_f32_Stages1and2and3andBitReverse:
;----------------------------------------------------------------------
;     Save all save-on-entry registers used
;----------------------------------------------------------------------
        PUSH     XAR1
        PUSH     XAR2
        PUSH     XAR3
        MOV32    *SP++,R4H
        MOV32    *SP++,R5H
        MOV32    *SP++,R6H
        MOV32    *SP++,R7H
        ADDB     SP,#14h

        MOVL     XAR2,*+XAR4[0]         ; &Inbuf
        MOVL     XAR5,*+XAR4[2]         ; &Outbuf
        MOVL     XAR3,*+XAR4[2]
        ADDB     XAR3,#8                ; &Outbuf[4]
        MOVL     XAR7,*+XAR4[4]         ; &CosSinbuf

        MOV      AR0,#0Ah
        MOV      AH,*+XAR4[AR0]         ; FFT SIZE
        MOV      AR0,AH
        LSR      AH,3
        SUBB     AH,#1                  ; (Size / 8) - 1
        MOVL     XAR1,#0000h            ; index if memory is not aligned

        RPTB    _rfft_32_Last, AH
;--------------------------------------------------------------------------------
;  Input buffer must be aligned for this code
;--------------------------------------------------------------------------------
        NOP     *,ARP2

        MOVL    ACC,*BR0++
        MOVL   *-SP[I1],ACC             ;I1

        MOVL    ACC,*BR0++
        MOVL    *-SP[I2],ACC            ;I2

        MOVL    ACC,*BR0++
        MOVL    *-SP[I3],ACC            ;I3

        MOVL    ACC,*BR0++
        MOVL    *-SP[I4],ACC            ;I4

        MOVL    ACC,*BR0++
        MOVL    *-SP[I5],ACC            ;I5

        MOVL    ACC,*BR0++
        MOVL    *-SP[I6],ACC            ;I6

        MOVL    ACC,*BR0++
        MOVL    *-SP[I7],ACC            ;I7

        MOVL    ACC,*BR0++
        MOVL    *-SP[I8],ACC            ;I8

;-------------------------------------------------------------------------------
; Computations for stages 1 2, and 3
;   OutBufIndex++ = (I1 + I2) + (I3 + I4) + (I5 + I6) + (I7 + I8);      (A)  <- XAR5
;   OutBufIndex++ = (I1 - I2) + COS x ((I5 - I6) + (I8 - I7));          (B)
;   OutBufIndex++ = (I1 + I2) - (I3 + I4);                              (C)
;   OutBufIndex++ = (I1 - I2) - COS x ((I5 - I6) + (I8 - I7));          (D)
;   OutBufIndex++ = ((I1 + I2) + (I3 + I4)) - ((I5 + I6) + (I7 + I8));  (E)  <- XAR3
;   OutBufIndex++ = COS x ((I8 - I7) - (I5 - I6)) - (I4 - I3);          (F)
;   OutBufIndex++ = (I7 + I8) - (I5 + I6);                              (G)
;   OutBufIndex++ = COS x ((I8 - I7) - (I5 - I6)) + (I4 - I3);          (H)
;-------------------------------------------------------------------------------
        MOV32       R0H, *-SP[I8]           ; R0H   = I8
        MOV32       R1H, *-SP[I7]           ; R1H   = I7
        SUBF32      R2H, R0H, R1H           ; R2H   = I8-I7
     || MOV32       R3H, *-SP[I5]           ; R3H   = I5
        ADDF32      R0H, R1H, R0H           ; R0H   = I7+I8
     || MOV32       R4H, *-SP[I6]           ; R4H   = I6
        SUBF32      R1H, R3H, R4H           ; R1H   = I5-I6
     || MOV32       R5H, *-SP[I1]           ; R5H   = I1
        ADDF32      R3H, R3H, R4H           ; R3H   = I5+I6
        ADDF32      R4H, R1H, R2H           ; R4H   = (I5-I6) + (I8-I7)
     || MOV32       R6H,*XAR7               ; R6H   = COS
        SUBF32      R7H, R0H, R3H           ; R7H   = (I7+I8) - (I5+I6)  (G)
        MPYF32      R4H, R6H, R4H           ; R4H   = COS x ((I5-I6) + (I8-I7))
     || SUBF32      R2H, R2H, R1H           ; R2H   = (I8-I7) - (I5-I6)
        ADDF32      R0H, R3H, R0H           ; R0H   = (I5+I6) + (I7+I8)
     || MOV32       *+XAR3[4], R7H          ; store G
        MPYF32      R2H, R6H, R2H           ; R2H   = COS x ((I8-I7) - (I5-I6))
     || MOV32       R7H, *-SP[I2]           ; R7H   = I2
        SUBF32
最低0.47元/天 解锁文章
秋暮霞惋红曲
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个很好用的汇编FFT原程序
09-12
很少见到用汇编编写FFT的，只因太繁琐。本程序用纯汇编写成，尽管繁琐，但你调用就简单啦。
64点FFT 51汇编语言算法
02-11
64点快速富式变换，基于C8051F120 mcu实现，用汇编语言编写，对于那些只会使用汇编语言的人来说，是一份难得的资料，已在项目中应用了的。
FFT的8088汇编语言程序实现
11-27
讲叙了FFT的基本原理，不同语言下FFT运算速度的比较
FFT算法具体代码实现
weixin_39227217的博客
04-26 487
在函数内部，我们首先对输入的序列长度进行判断，如果长度为1，则递归结束，直接返回该序列作为DFT结果。在完成自定义的FFT算法之后，我们通过测试代码来验证算法的正确性，即用numpy库自带的fft函数计算结果与我们自己编写的fft函数计算结果是否相同。需要注意的是，虽然该代码并非最优化的FFT实现方式，但是它足以帮助我们理解FFT的算法思想、执行过程等重要概念。闲话不多说，以下是一个Python的FFT算法模拟程序，其中利用了numpy库中的fft函数来实现FFT算法。
TIDSP281xFFT例程
08-10
TI给的FFT库，用于DSP281x系列，很好的FFT例程
fft.zip_fft 汇编
09-23
描述中的"DSPC5402 FFT汇编完整算法，与教材一致"说明了这个压缩包提供的是一套完整的 FFT 汇编代码，适用于 DSPC5402 芯片，并且其算法设计与教科书中的理论保持一致。这意味着它遵循了标准的 FFT 实现流程，如 ...
fft1drad2cmpx_121900.zip_FFT ASM_fft 汇编_fft汇编
09-14
标题中的"fft1drad2cmpx_121900.zip_FFT ASM_fft 汇编_fft汇编"指示了这个压缩包文件主要内容是关于单精度复数快速傅里叶变换（FFT）的汇编语言实现。快速傅里叶变换是一种在数字信号处理、图像处理、计算机科学和...
FFT.rar_4 fft_dsp FFT_fft 4_fft 汇编_汇编语言FFT
09-23
5. FFT汇编实现：在汇编语言中实现FFT，需要对FFT算法的结构有深入理解，包括蝶形运算、位反转和复数运算。汇编实现可能需要更精细的控制，以利用DSP的硬件特性，例如，通过向量操作和流水线来并行处理多个数据点。 ...
fft.zip_FFT ASM_asm fft_fft 汇编_fft 汇编 程序_汇编语言FFT
09-22
这个压缩包包含的是一套使用汇编语言实现的FFT程序，这对于理解FFT算法的底层运作机制以及优化性能具有重要意义。 汇编语言是一种低级编程语言，它直接对应于计算机的机器指令，因此用汇编编写的程序通常运行速度更...
FixedPoint:C++ 中的定点算法库
06-01
定点库 这是一个简单的库，以 2 个 hpp 文件的形式提供程序定点功能。 它的设计目的是在没有浮点单元的嵌入式环境中使用，因此定点运算效率更高。 了解该库的最佳方式是阅读examples.hpp 。 概述 定点运算的问题在于程序员通常需要跟踪整数的哪一部分是小数，哪一部分是整数。 例如，如果您使用 Q4.12 格式（小数点前 4 位，小数点后 12 位），您必须记住概念值“1”实际上存储为“4096”。 在定点数之间执行运算时，重要的是要跟踪事物，以免以不合逻辑的方式组合事物。 定点库通过引入FixedPoint<m>类型来解决这个问题，该类型以存储数字。 使用该类型不会引入运行时开销，因为小数点的位置仅在编译时与数字相关联。 使用该类型有几个好处： 编译器将捕获您希望数字具有特定格式但实际上并非如此的常见错误 该类型将自动执行一些转换，例如添加或比较不同 Q 格式的数字。 明
FFT算法汇编原程序与大家共享.rar_FFT算法_FFT算法程序_fft_fft c++_fft 汇编
09-20
在给定的压缩包文件中，"FFT算法汇编原程序与大家共享.rar"可能包含了用汇编语言实现的FFT算法源代码，以及一些相关的文档。汇编语言是一种低级编程语言，直接对应于计算机的机器指令，对于性能敏感的应用如FFT，...
DSP操作教程 4-7 快速傅立叶变换（FFT）算法（CCS显示）
Tronlongtech的博客
09-20 2694
在计算机上进行的DFT，使用的输入值是时域的信号值，输入采样点的数量决定了转换的计算规模。FFT和FFT 逆变换函数中的第五个参数brev是指向包含64个表项的位反转表的指针，因此程序中需要提供64个表项，程序中的位反向表是计算出来的，可以通过代码提前转换的。离散傅里叶变换作为信号处理中最基本和最常用的运算，在信号处理领域占有基础性的地位，如果直接按照离散傅里叶变换的公式进行计算，求出N点X(k)需要N^2次复数运算、N(N-1)次复数加法，当N很大时，运算量是非常大的，这对于实时处理是无法接受的。
C语言实现数字滤波器
amen_yanwang的博客
01-31 1183
记载，数字滤波器
STM32 FFT 汇编定点FFT库（64，256，1024点）
输出每日所学，供大家学习使用
10-28 3080
x[n]是采样信号 n得满足4^n（n =1，2, 3……），也就是以4为基数。 采样信号必须是32位数据，高16位存实部，低16位存虚部（这个是针对大端模式），小端模式是高位存虚部，低位存虚部。一般常用的是小端模式。 cr4_fft_64_stm32 ：实现64点FFT。 cr4_fft_256_stm32 ：实现256点FFT。 cr4_fft_1024_stm32 ： 实现1024点FFT。 移植 添加这几个文件到自己的工程 在stm32_dsp.h文件中添加f4的头文件 其他几个点类似，
离散数据如何进行fft_【玩转单片机系列002】 如何使用STM32提供的DSP库进行FFT
weixin_26843605的博客
01-25 944
前些日子，因为需要在STM32F103系列处理器上，对采集的音频信号进行FFT，所以花了一些时间来研究如何高效并精确的在STM32F103系列处理器上实现FFT。在网上找了很多这方面的资料做实验并进行比较，最终选择了使用STM32提供的DSP库这种方法。　　本文将以一个实例来介绍如何使用STM32提供的DSP库函数进行FFT。1.FFT运算效率　　使用STM32官方提供的DSP库进行FFT，虽然在...
FFT算法的实现（2）
Egean的博客
11-21 5058
上一篇文章当中已经推导出了整个频域上的表达式，这个表达式叫做蝶形运算，下面就借由蝶形运算实现FFT算法。 那么首先就要先说说蝶形运算。蝶形运算听着挺高大上的，但可以有一种简单方便的图形表示方法，为方便起见我这里再贴一次公式： \\ X[k]=X0[k]+WkNX1[k]X[k]=X0[k]+WNkX1[k] X[k]=X_0[k]+W_N^{k}X_1[k] X[k+N2]=X0[k...
单片机c语言fft函数,单片机ADC采样FFT计算试验
weixin_29595517的博客
05-19 1546
_jisuanfudu: [url=home.php?mod=space&uid=72445]@[/url] 计算幅度[url=home.php?mod=space&uid=72445]@[/url] 入r0= 实部，r1= 虚部@ 出r0 = 幅度@ Mag ~=Alpha * max(|I|, |Q|) + Beta * min(|I|, |Q|)@ Alpha ...
适用于单片机的FFT快速傅里叶变换算法，51单片机都能用
热门推荐
乙酸氧铍的博客
11-10 1万+
目录源码FFT.cFFT.h使用方法效果其他部分的代码main.c 普中51-单核-A2 STC89C52 Keil uVision V5.29.0.0 PK51 Prof.Developers Kit Version:9.60.0.0 算法来自FFT算法的使用说明与C语言版实现源码 —— 原作者：吉帅虎 移植十分简单，不依赖其他库，可自定义点数 源码 FFT.c /********************************************************************
dsp开发与arm开发有什么区别，应用差别
最新发布
icon_sunshine的博客
06-04 2428
此外，DSP处理器通常具有专门的指令集，这些指令集专为提高常用的信号处理算法的效率而设计，例如单周期乘加指令、逆序加减指令等。ARM处理器使用的是RISC指令集，这种指令集设计简洁，能够在单个时钟周期内完成指令的执行，这有助于提高处理器的能效。DSP处理器在数字信号处理领域的优势主要体现在其高速的数据处理能力、专门的指令集、并行处理能力、高速RAM和独立数据总线、低开销的循环及跳转支持、快速的中断处理和硬件I/O支持、多个硬件地址生成器以及支持多种操作模式等方面。
用汇编实现FFT
05-24
FFT（快速傅里叶变换）是一种复杂的算法，用汇编实现需要耗费大量时间和精力。下面是一个简单的例子，可以实现8点FFT： ```assembly ;============================================= ; 8-point FFT in assembly language ;============================================= .model small .stack 100h .data x_real dw 4, 0, 4, 0, 4, 0, 4, 0 x_imag dw 0, 0, 0, 0, 0, 0, 0, 0 w_real dw 8, 0, -1, 7, 0, -8, 1, -7 w_imag dw 0, -8, 7, -1, 8, 0, -7, 1 .code main PROC mov ax, @data mov ds, ax ; do the FFT call fft_8 mov ax, 4c00h int 21h main ENDP ;--------------------------------------------- ; subroutines ;--------------------------------------------- fft_8 PROC push ax push bx push cx push dx ; first pass mov cx, 4 mov dx, 2 L1: mov bx, cx L2: mov ax, x_real[bx] add ax, x_real[bx+dx] mov x_real[bx+dx], ax sub ax, x_real[bx] mov x_real[bx], ax mov ax, x_imag[bx] add ax, x_imag[bx+dx] mov x_imag[bx+dx], ax sub ax, x_imag[bx] mov x_imag[bx], ax add bx, dx cmp bx, 8 jle L2 sub cx, 1 cmp cx, 0 jne L1 ; second pass mov cx, 2 mov dx, 4 L3: mov bx, cx mov ax, x_real[bx] mov si, w_real[bx] mov di, w_imag[bx] mov bx, dx L4: mov bp, x_real[bx] mov bx, x_imag[bx] mov bl, dil mov bh, sih mov si, x_real[bx] mov di, x_imag[bx] mov cl, dil mov ch, sih mov ax, bp mul cl mov bp, ax mov ax, bx mul bh sub bp, ax mov ax, si mul ch add bp, ax mov ax, di mul bl add bp, ax mov x_real[bx], bp mov ax, bp mov bx, si mul dil mov bp, ax mov ax, di mul sih sub bp, ax mov ax, bp mov bx, si mul sih add ax, di mov x_imag[bx], ax add bx, dx cmp bx, 8 jle L4 add cx, 1 cmp cx, 4 jle L3 pop dx pop cx pop bx pop ax ret fft_8 ENDP END main ``` 上述代码实现了一个简单的8点FFT。实现FFT需要了解复数运算、旋转因子等一系列概念，因此需要有一定的数学和计算机基础。同时，汇编语言的代码相对于高级语言更加底层，需要更加细致的调试和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值