nRF24L01学习（1）

最新推荐文章于 2024-06-20 10:42:49 发布
最新推荐文章于 2024-06-20 10:42:49 发布
阅读量781 收藏 9
点赞数
分类专栏： 笔记
本文链接：https://blog.csdn.net/orangesssss/article/details/108674296
版权

nRF24L01学习（1）

时间： 2020年9月14日~9月18日
设备： 树莓派4B、nRF24L01无线模块
语言： Python

前言

第一次使用python写东西（Hello World除外)，第一次使用树莓派完成某个功能，第一次接触SPI接口的工作原理，所以过程坎坷，简单的驱动程序花了一周时间，而且只是完成了发送端的驱动程序，但是这算是我朝某个目标行进的第一步，码住留以后查阅。

遇到的问题

1、SPI接口的理解

这个问题是我遇到的最大的问题，也是花费时间最多的。

学习的开始就是查阅资料看看前人经验，但是我查阅了两天时间网上关于nRF24L01的经验全部是关于寄存器的，这段时间学到了寄存器的值对nRF状态的影响和反映，但是对于如何用八个管脚去处理那么多寄存器毫无头绪。把电源、时钟、片选、中断管脚排除后，确定树莓派和nRF交流仅靠MOSI和MISO两个管脚后，一点一点分析别人的代码，最后到了第三天才慢慢知道nRF怎么区分树莓派送过来的信号是指令还是数据。

大多数情况下，树莓派和nRF的交流每次以八位二进制为一个单位进行，而主机对nRF的指令是固定不变的信号类似关键字。

例如nRF从MOSI管脚收到树莓派的一个信号为00000000，这是读取地址为00000寄存器的指令，即树莓派让nRF在下一次交流的时候把地址为00000的寄存器里的数据从MISO发过来，所以树莓派在发送读取指令后一般会从MOSI再发送11111111（空操作指令）当作下一次的交流让nRF把东西从MISO发过来。所以树莓派要读地址为AAAAA寄存器的内容，就从MOSI管脚发送000AAAAA，再发送11111111同时读取MISO返回来的数据。

又如nRF从MOSI管脚收到00110000，这是改写地址为10000寄存器的指令，即树莓派告诉nRF“我会在下一次交流把要填入10000寄存器的数据发过来”，之后就通过MOSI进行下一次交流把要填入的八位二进制输进去，而不是像读寄存器指令一样发送11111111。总的来说，树莓派要改写地址为AAAAA寄存器的内容，就从MOSI进行两次交流，即发送两次信号，001AAAAA（指令）和BBBBBBBB（要填入的八位二进制）。

而其它指令不需要知道寄存器地址，就是完全固定死的信号：
RD_RX_PLOAD 0x61(01100001) 读取接收数据寄存器指令
WR_TX_PLOAD 0xA0(10100000) 写入发送数据寄存器指令
FLUSH_TX 0xE1(11100001) 清除发送数据寄存器指令
FLUSH_RX 0xE2(11100010) 清除接收数据寄存器指令
REUSE_TX_PL 0xE3(11100011) 数据重发指令
NOP 0xFF(11111111) 空操作用于读寄存器

nRF和主机交流一次，MOSI和MISO怎么传输信号？

srdata = '01010101'
ssrdata = list(srdata)
def SPI_RW_reg(sdata):
    i = 0
    GPIO.output(send_CLK,0)			#时钟控制
    for ii in sdata:							#八位二进制逐个交替交换
        time.sleep(0.0001)						#
        GPIO.output(send_mosi, int(ii))		   #第i位二进制输出
        GPIO.output(send_CLK,1)		#时钟控制	#ii为1就输出高电平
        time.sleep(0.0001)						#ii为0就输出低电平
        ssrdata[i] = str(GPIO.input(send_miso))#第i位二进制输入
        GPIO.output(send_CLK,0)		#时钟控制	#同理
        i = i + 1
    srdata = ''.join(ssrdata)
    return srdata					#返回收到的八位二进制
2、Python处理二进制数

因为nRF和主机交流一次是八位二进制交替进行，所以二进制的处理就显得比较重要了，但是Python用其它进制表示数据必须是str类型，然后前面带着进制标志（0b，0o，0x）。
所以我干脆使用str类型处理二进制数，然后单个二进制数处理过程就是利用list()函数把字符串变成列表，把各位分隔后再利用int和str的转换进行赋值和输出等操作，完成处理后再用’’.join()整合回字符串；而对于非单个二进制数的处理，就直接照着str类型处理就好了。

srdata = '01010101'
ssrdata = list(srdata)					#中间列表
def SPI_RW_reg(sdata):
    i = 0
    GPIO.output(send_CLK,0)
    for ii in sdata:
        time.sleep(0.0001)
      	GPIO.output(send_mosi, int(ii))			#str型转换为int型输出
        GPIO.output(send_CLK,1)
        time.sleep(0.0001)
        ssrdata[i] = str(GPIO.input(send_miso))	#输入的int型转换为str型赋值
        GPIO.output(send_CLK,0)
        i = i + 1
    srdata = ''.join(ssrdata)
    return srdata
3、分段检查

代码写完后运行，不报错但是查看nRF的FIFO_STATUS和STATUS寄存器发现两个nRF没有完成无线通信，我怎么知道是发送端的问题还是接收端的问题？
网上检查发送端问题基本是通过发送端是否接收到接收端应答信号判断是否发送成功，但是接收不到应答信号也不能判断是发送端还是接收端的问题，这就比较鸡肋了。最后在一个论坛找到了解决办法。
基本思想就是关闭两端的自动应答，之后才能通过状态寄存器的值判断是没发送成功还是没接收成功。其实认真阅读nRF的手册，就可以知道这个办法。orangesssss
这也暴露了我的一个大问题，对资料的细节关注不够才导致了我的摸索坎坷。

4、接收不到数据

检查状态寄存器无变化，载波检测也无变化，发送端和接收端地址一致、频率一致、数据宽度一致。我猜测是时序问题，或者是我没注意到的设置细节问题。但时间问题，确认发送端发送没问题后，接收端问题留下次学习的时候寻找。

完整代码

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
#管脚设置
send_IRQ = 24       # interrupt
send_CLK  = 25      # clock
send_CSN = 8        # select
send_mosi = 10
send_miso  = 9
rec_IRQ = 5      
rec_CLK  = 16      
rec_CSN = 7       
rec_mosi = 20 
rec_miso = 19
send_CE = 6
rec_CE = 26
GPIO.setup(send_CLK,GPIO.OUT)
GPIO.setup(rec_CLK,GPIO.OUT)
GPIO.setup(send_mosi,GPIO.OUT)
GPIO.setup(send_miso,GPIO.IN)
GPIO.setup(rec_mosi,GPIO.OUT)
GPIO.setup(rec_miso,GPIO.IN)
GPIO.setup(send_CSN,GPIO.OUT)
GPIO.setup(rec_CSN,GPIO.OUT)
GPIO.setup(send_CE,GPIO.OUT)
GPIO.setup(rec_CE,GPIO.OUT)
GPIO.setup(send_IRQ,GPIO.IN)
GPIO.setup(rec_IRQ,GPIO.IN)

GPIO.output(send_CSN,1)		#片选信号拉高初始化
GPIO.output(rec_CSN,1)


srdata = '01010101'
print(GPIO.input(send_IRQ))	#中断检查
ssrdata = list(srdata)
def SPI_RW_reg(sdata):      #发送端树莓派与nRF交流的函数
    i = 0
    GPIO.output(send_CLK,0)
    for ii in sdata:
        time.sleep(0.0001)
        GPIO.output(send_mosi, int(ii))
        GPIO.output(send_CLK,1)
        time.sleep(0.0001)
        ssrdata[i] = str(GPIO.input(send_miso))
        GPIO.output(send_CLK,0)
        i = i + 1
    srdata = ''.join(ssrdata)
    return srdata

rdata = '00000000'
rrsdata = list(rdata)
def SPI_rec_RW_reg(rsdata):       #接收端树莓派与nRF交流的函数
    GPIO.output(rec_CLK,0)
    jj = 0
    for j in rsdata:
        time.sleep(0.0001)
        GPIO.output(rec_mosi,int(j))
        GPIO.output(rec_CLK,1)
        time.sleep(0.0001)
        rrsdata[jj] = str(GPIO.input(rec_miso))
        GPIO.output(rec_CLK,0)
        jj = jj + 1
    rdata = ''.join(rrsdata)
    return rdata

def s_write_reg(ADDR,data):       #发送端改写nRF寄存器的值
    command = ['0','0','1','0','0','0','0','0']
    addr = list(ADDR)
    command[3] = addr[3]
    command[4] = addr[4]
    command[5] = addr[5]
    command[6] = addr[6]
    command[7] = addr[7]
    GPIO.output(send_CSN,0)
    addr0 = ''.join(command)
    SPI_RW_reg(addr0)
    SPI_RW_reg(data)
    GPIO.output(send_CSN,1)

def r_write_reg(ADDR,data):      #接收端改写nRF寄存器的值
    command = ['0','0','1','0','0','0','0','0']
    addr = list(ADDR)
    command[3] = addr[3]
    command[4] = addr[4]
    command[5] = addr[5]
    command[6] = addr[6]
    command[7] = addr[7]
    GPIO.output(rec_CSN,0)
    addr0 = ''.join(command)
    SPI_rec_RW_reg(addr0)
    SPI_rec_RW_reg(data)
    GPIO.output(rec_CSN,1)

def s_read_reg(ADDR):       #发送端读取寄存器的值
    command = ['0','0','0','0','0','0','0','0']
    addr = list(ADDR)
    command[3] = addr[3]
    command[4] = addr[4]
    command[5] = addr[5]
    command[6] = addr[6]
    command[7] = addr[7]
    addr0 = ''.join(command)
    GPIO.output(send_CSN,0)
    SPI_RW_reg(addr0)
    data = SPI_RW_reg('11111111')
    GPIO.output(send_CSN,1)
    return data

def r_read_reg(ADDR):       #接收端读取寄存器的值
    command = ['0','0','0','0','0','0','0','0']
    addr = list(ADDR)
    command[3] = addr[3]
    command[4] = addr[4]
    command[5] = addr[5]
    command[6] = addr[6]
    command[7] = addr[7]
    addr0 = ''.join(command)
    GPIO.output(rec_CSN,0)
    SPI_rec_RW_reg(addr0)
    data = SPI_rec_RW_reg('11111111')
    GPIO.output(rec_CSN,1)
    return data

recdata = ['00000000','00000000','00000000','00000000','00000000']
def r_read_RXFIFO():      #接收端读取接受数据寄存器
    GPIO.output(rec_CSN,0)
    SPI_rec_RW_reg('01100001')
    for num in range(0,5):
        recdata[num] = SPI_RW_reg('11111111')
        print('receive data' + recdata[num])
    GPIO.output(rec_CSN,1)
    return recdata

def s_read_RXFIFO():         	 #发送端读取接受数据寄存器
    GPIO.output(send_CSN,0)
    SPI_RW_reg('01100001')
    for num in range(0,5):
        recdata[num] = SPI_RW_reg('11111111')
        print('receive data' + recdata[num])
    GPIO.output(send_CSN,1)
    return recdata

def r_write_TXFIFO(data):        #接收端写入发送数据寄存器
    GPIO.output(rec_CSN,0)
    SPI_rec_RW_reg('10100000')
    SPI_rec_RW_reg(data)
    GPIO.output(rec_CSN,1)

def s_write_TXFIFO(data):        #发送端写入发送数据寄存器
    GPIO.output(send_CSN,0)
    SPI_RW_reg('10100000')
    SPI_RW_reg(data)
    GPIO.output(send_CSN,1)

#清除数据寄存器
def s_FLUSHTX():
    GPIO.output(send_CSN,0)
    SPI_RW_reg('11100001')
    GPIO.output(send_CSN,1)

def r_FLUSHTX():
    GPIO.output(rec_CSN,0)
    SPI_rec_RW_reg('11100001')
    GPIO.output(rec_CSN,1)

def s_FLUSHRX():
    GPIO.output(send_CSN,0)
    SPI_RW_reg('11100010')
    GPIO.output(send_CSN,1)

def r_FLUSHRX():
    GPIO.output(rec_CSN,0)
    SPI_rec_RW_reg('11100010')
    GPIO.output(rec_CSN,1)

checkdata = ['00000000','00000000','00000000','00000000','00000000']

#检查和设置发送端和接收端地址的函数
def rcheck_RXADDR_P0():
    GPIO.output(rec_CSN,0)
    SPI_rec_RW_reg('00001010')
    for num in range(0,5):
        checkdata[num] = SPI_rec_RW_reg('11111111')
    GPIO.output(rec_CSN,1)
    return checkdata

def scheck_TXADDR():
    GPIO.output(send_CSN,0)
    SPI_RW_reg('00010000')
    for num in range(0,5):
        checkdata[num] = SPI_RW_reg('11111111')
    GPIO.output(send_CSN,1)
    return checkdata

def swrite_TXADDR(addrdata):
    GPIO.output(send_CSN,0)
    SPI_RW_reg('00110000')
    for num in range(0,5):
        SPI_RW_reg(addrdata[num])
    GPIO.output(send_CSN,1)

def rwrite_RXADDR_P0(addrdata):
    GPIO.output(rec_CSN,0)
    SPI_rec_RW_reg('00101010')
    for num in range(0,5):
        SPI_rec_RW_reg(addrdata[num])
    GPIO.output(rec_CSN,1)

#set mode配置状态寄存器config第二位PWR_UP置1后经过1.5ms才进入状态-I
s_write_reg('00000000','00001110')
r_write_reg('00000000','00001111')
time.sleep(0.0015)

#set ADDR设置发送端和接受端地址，二者一样才能通信
swrite_TXADDR(['11100111','11100111','11100111','11100111','11100111'])
rwrite_RXADDR_P0(['11100111','11100111','11100111','11100111','11100111'])

#set EN_AA关闭自动应答，方便分开检查发送和接收的完成情况
s_write_reg('00000001','00000000')
r_write_reg('00000001','00000000')

#set EN_RXADDR接收数据通道使能
s_write_reg('00000010','00000000')
r_write_reg('00000010','00000001')

#set SETUP_RETR关闭自动应答，方便分开检查发送和接收完成情况
s_write_reg('00000100','00000000')
r_write_reg('00000100','00000000')

#set RF_CH设置发送频率
s_write_reg('00000101','01111111')
r_write_reg('00000101','01111111')

#set RF_SETUP设置数据传输率和发射功率
s_write_reg('00000110','00001111')
r_write_reg('00000110','00001111')

#设置接收有效数据宽度
r_write_reg('000010001','00000001')

#清除发送数据寄存器，并输入待发送的信号
s_FLUSHTX()
data_tosend = input('input the data tosend:')
for num in range(0,5):
    s_write_TXFIFO(data_tosend)
print('s_FIFO_STATUS' + s_read_reg('00010111'))


GPIO.output(rec_CE,1)   	#使接收端进入接收模式,置1后需等待130us
time.sleep(0.0002)     		#等待200us

#开始发送
for num in range(0,5):
    GPIO.output(send_CE,1)
    time.sleep(0.00002)     #等待20us，因为CE需要保持高电平10us以上
    GPIO.output(send_CE,0)
    time.sleep(0.0002)      #等待200us，条件满足后需要130us才完成发送

print('CD' + r_read_reg('00001001')) #查看接收端是否检测到载波信号
GPIO.output(rec_CE,0)

#检查发送端和接收端的状态
print('s_STATUSreg' + s_read_reg('00000111'))
print('s_FIFO_STATUS' + s_read_reg('00010111'))
print('r_STATUSreg' + r_read_reg('00000111'))
print('r_FIFO_STATUS' + r_read_reg('00010111'))
#查看接收端接收数据寄存器的值
print('received data' + str(r_read_RXFIFO()))

GPIO.cleanup()               #清除管脚设置

学习资料

nRF24L01中文手册
nRF24L01寄存器中文手册
nRF24L01工作原理解析
代码借鉴

orangesssss
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树莓派 nRF24L01+ 驱动模块（Pythno3）
06-22
V2.0版，基于树莓派的Python3，在自制树莓派遥控器上调试通过~
Arduino Nano驱动nRF24L01模块
07-14
**Arduino Nano驱动nRF24L01模块详解** 在电子制作和物联网项目中，nRF24L01是一款非常流行的2.4GHz无线通信模块。它以其低成本、低功耗和相对简单的使用方式而受到众多DIY爱好者和开发者的青睐。在本篇中，我们将...
树莓派与Arduino Leonardo使用NRF24L01无线模块通信之基于RF24库 (一) 配置与测试...
weixin_30597269的博客
02-09 1011
引脚连接说明 与树莓派的连线 NRF24L01 => 树莓派 GND => GND VCC => 3.3V CE => GPIO25 即22管脚 CSN => CE0(GPIO8) 即 24管脚 SCK => SCLK(GPIO11)即23...
无线通信芯片之NRF24L01
m0_50758340的博客
06-20 505
是由NORDIC生产的工作在2.4GHz~2.5GHz的ISM 频段的单片无线收发器芯片。无线收发器包括：频率发生器、增强型“SchockBurst”模式控制器、功率放大器、晶体振荡器、调制器和解调器。应用领域● 无线鼠标 键盘 游戏机操纵杆● 无线门禁● 无线数据通讯● 安防系统● 遥控装置● 遥感勘测● 智能运动设备● 工业传感器● 玩具。
NRF24L01 2.4G无线模块浅析（学习笔记）
热门推荐
Super辉sir的博客
03-30 5万+
仅作为个人学习笔记，本文将介绍NRF24L01的基本工作原理以及如何通过代码控制无线模块（参考正点原子示例），不讲SPI。 文章目录芯片简介引脚及功能工作模式数据通道SPI 指令寄存器地址NRF24L01模块驱动（STM32)简单的通讯代码 芯片简介 nRF24L01是由NORDIC生产的工作在2.4GHz~2.5GHz的ISM 频段的单片无线收发器芯片。无线收发器包括：频率发生器、增强型“SchockBurst”模式控制器、功率放大器、晶体振荡器、调制器和解调器。 应用领域 ● 无线鼠标 键盘 游.
51驱动NRF24L01通信，NRF24L01与TTL转NRF24L01模块通信
优信电子的博客
03-10 7316
NRF24L01 是 NORDIC 公司最近生产的一款无线通信通信芯片，采用 FSK 调制，内部集成 NORDIC 自己的 Enhanced Short Burst 协议。可以实现点对点或是 1 对 6 的无线通信。无线通信速度可以达到 2M（bps）。NORDIC 公司提供通信模块的 GERBER 文件，可以直接加工生产。嵌入式工程师或是单片机爱好者只需要为单片机系统预留 5 个 GPIO，1 个中断输入引脚，就可以很容易实现无线通信的功能，非常适合用来为 MCU 系统构建无线通信功能。
学习一：NRF24L01
m0_47628734的博客
03-06 363
自动ACK（自动应答）：是指可以接收到数据后，自动返回ACK告诉发送端，自动返回的地址就是通道0的地址。IRQ引脚用于观察是否接收到数据，如果IRQ为低电平则代表接收到数据了。可以1收6发，接收端的地址可以识别6个发送端。通过寄存器和寄存器的命令相互配合调节使用。模块的配置：（新买回来的需要配置）通过配置内部寄存器来控制。
NRF24L01入门总结
izar的博客
11-23 1万+
nRF24L01 是一款工作在 2.4~2.5GHz 世界通用 ISM 频段的低功耗单片无线收发器芯片。无线收发器包括:频率发生器、增强型 SchockBurstTM 模式控制器、功率放大器、晶体振荡器、调制器、解调器。输出功率、频道选择和协议的设置可以通过 SPI 接口进行设置。 目录一、NRF24L01功能特性二、怎么控制（读写）NRF24L01?三、总体了解NRF24L01工作模式四、怎样实现一个NRF24L01发送，另一个就能收到呢？五、自动应答和自动重发需要注意什么呢？六、一对一通信比较简单、.
NRF24L01详解
留小乙的博客
10-06 3万+
一、NRF24L01简介 NRF24L01是NORDIC公司生产的一款无线通信通信芯片，采用FSK 调制，集成NORDIC自家的Enhanced Short Burst协议。可以实现点对点或是1对6的无线通信。无线通信速度最高可达到2Mbps。 NRF24L01采用SPI通信，可以很方便的连接到MCU上面。 特点： ①2.4G全球开放的ISM频段，免许可证使用。 ②最高工作速率2Mbps，高校的GFSK调制，抗干扰能力强。 ③126个可选的频道，满足多点通信和调频通信的需要。 ④内置CRC检错和点对多点的通
nRF24L01的发送性能优化
IOsetting的专栏
09-13 947
RF24项目代码分析 头文件 https://github.com/nRF24/RF24/blob/master/RF24.h 源文件 https://github.com/nRF24/RF24/blob/master/RF24.cpp 数据流发送/接收例子 https://github.com/nRF24/RF24/blob/master/examples_linux/streamingData.cpp 函数 bool writeFast(const void* buf, uint8_t len) 这
NRF24L01调试的一些经验之谈
ai5945fei的博客
05-12 1310
这次大大小小又搞了一个星期，还特地做了测试版。 图中大部分是SI24R1，和NRF24L01+完全兼容，关键是还便宜。 需求要做一个无线通讯大网，一个主机和上百个从机通讯。 该模块有自动应答功能，发送一个包到应答数据收到，只需要1ms以内的时间就能完成，数据包还自带CRC校验。比485，CAN总线这些高效很多。还不需要布线。 说说经验记录， 1、不管是PTX还是PRX端，在初始化模块之后，CE一直保持高即可，不要去操作CE脚。PTX端发送缓冲区有数据就自动发送，无数据就等待有数据再.
NRF24L01-状态寄存器
ai5945fei的博客
12-17 1528
STATUS寄存器 当接受到数据后BIT_RX_DR置1，并且RX_P_NO 设置为对应接收通道。 当读取出接收缓冲区数据后，RX_P_NO 变为111，但BIT_RX_DR不变，需手动清除。 BIT_RX_DR可以不清除，只需要把数据读出就可以再次接收。即使BIT_RX_DR清除，RX_P_NO和数据依然有效。 所以，为了防止标志位BIT_RX_DR手动清除的延时问题，可以不关心BIT_RX_DR，只判断RX_P_NO，当他小于6时，说明有数据，读出自动清除RX_P_NO。 FI..
NRF24L01 .C .H文件
05-17
NRF24L01是一款低功耗、2.4GHz无线收发芯片，广泛应用于无线通信领域，如智能家居、物联网(IoT)设备等。STM32F1系列是意法半导体(STMicroelectronics)推出的基于ARM Cortex-M3内核的微控制器，具有高性能、低功耗的...
NRF24L01.rar
06-13
1. **理解芯片原理**：深入研究NRF24L01的数据手册，了解其寄存器结构和通信协议。 2. **编写配置函数**：根据手册，编写读写寄存器的函数，例如`writeReg()`和`readReg()`，这些函数会通过SPI接口发送相应的命令和...
nRF24L01_NRF24L01_源码
10-03
1. **配置寄存器 (CONFIG)**: 这个寄存器用来设置 NRF24L01 的基本工作模式，如自动应答、CRC 检验等。例如，通过写入特定值可以开启或关闭数据包的 CRC 校验，以确保传输的可靠性。 2. **数据速率和发射功率寄存器...
NRF24L01+数据双向发送(无需收发模式切换)
05-23
1. **自动应答(Acknowledgment, ACK)**: NRF24L01+支持自动应答功能，当接收端接收到数据后，可以发送一个ACK包回给发送端，确认数据已成功接收。这有助于确保数据的可靠传输。 2. **管道(Pipes)**: NRF24L01+有6个...
2024浙江省行政区划矢量图层-省市县乡镇四级行政区划数据下载-带python代码
最新发布
08-02
2024最新浙江省行政区划矢量图层数据，包含省、市、县、乡镇四级行政区划数据下载，附带shp转geojson的python代码
年度销售计划表.xlsx.xlsx
08-01
销售统计，调查问卷，库存明细，跟进表，业绩统计表，差异分析 ，产品清单 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值