07.2PCF8591

最新推荐文章于 2024-08-14 20:15:00 发布
最新推荐文章于 2024-08-14 20:15:00 发布
阅读量47 收藏
点赞数
文章标签： 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69779423/article/details/132502734
版权

1.main.c文件

#include<stc15.h>
#include<intrins.h>
#include<IIC.H>

#define uchar unsigned char
#define uint unsigned int
	
unsigned char LED_Bit=0XFF;
unsigned char Actuator_Bit=0X00;

#define LEDx_ON(n) 	{ LED_Bit&=_crol_(0XFE,n-1); P0=LED_Bit; P2|=0X80;	P2&=0X9F;	P2&=0X1F;}
#define LEDx_OFF(n) { LED_Bit|=_crol_(0X01,n-1); P0=LED_Bit; P2|=0X80;	P2&=0X9F;	P2&=0X1F;}

#define Buzzer_ON 	Actuator_Bit|=0x40; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF; P2&=0X1F;		
#define Buzzer_OFF 	Actuator_Bit&=0XBF; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF;	P2&=0X1F;
#define Relay_ON 		Actuator_Bit|=0x10; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF;	P2&=0X1F;
#define Relay_OFF 	Actuator_Bit&=0XEF; P0=Actuator_Bit;	P2|=0XA0;	P2&=0XBF;	P2&=0X1F;

unsigned char code tab[]=	{0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,\
													 0X40,0X79,0X24,0X30,0X19,0X12,0X02,0X78,0X00,0X10,\
													 0XBF,0XFF};
unsigned char KEY_Value = 0 ;
unsigned char DigCom=0;
unsigned char DigBuf[8] = {10,10,10,10,10,10,10,10};

unsigned char LED = 1 ;
unsigned int LED_tt =0;
bit LED_Ref = 0 ;

unsigned int SEG_tt =0;		//定义一个数码管计数时间标识位
bit SEG_Ref = 0 ;					//定义一个数码管刷新标识位
bit SEG_Run = 0 ;					//定义一个控制数码管运行标识位
unsigned int Num = 999 ;

unsigned char Open;

unsigned char EEPROM_Write[8] = {2,3,4,5,6,7,8,9};
unsigned char EEPROM_Read[8] = {0,0,0,0,0,0,0,0};

unsigned int AD_VALUE=0;
unsigned int AD_tt =0;
bit AD_Ref =0;

unsigned int XXX_tt =0;
bit XXX_Ref =0;

void IO_Init(void);
void ALL_Init(void);
void Delay_MS(unsigned int MS);
void KeyScan(void);
void ArrKeyScan(void);
void Timer0Init(void);		//1毫秒@11.0592MHz

void main(void)
{
	IO_Init();
	ALL_Init();
	Timer0Init();
	EA=1;ET0=1;
	
//	AT24C02_write(0X15,0);Delay_MS(1);
	
//	Open = AT24C02_read(0X15); Delay_MS(5); 
//	AT24C02_write(0X15,++Open);Delay_MS(5);
//	DigBuf[0]=Open/10;DigBuf[1]=Open%10;
	
//	AT24C02_Write_Page(0X00);Delay_MS(5);
//	AT24C02_Read_Page(0X00);Delay_MS(5);
//	DigBuf[0]=EEPROM_Read[0];DigBuf[1]=EEPROM_Read[1];DigBuf[2]=EEPROM_Read[2];DigBuf[3]=EEPROM_Read[3];
//	DigBuf[4]=EEPROM_Read[4];DigBuf[5]=EEPROM_Read[5];DigBuf[6]=EEPROM_Read[6];DigBuf[7]=EEPROM_Read[7];
	
	while(1)
	{
		if(AD_Ref == 1)
		{
			AD_Ref = 0 ;
			AD_VALUE = AD_read(0X01);//读取不同通道模拟信号的值
			AD_write(AD_VALUE);
			
			AD_VALUE = AD_VALUE* 1.96 ;
			DigBuf[2]=21;DigBuf[3]=21;DigBuf[4]=21;
			DigBuf[5]=AD_VALUE/100+ 10 ; DigBuf[6]=AD_VALUE%100/10;
			DigBuf[7]=AD_VALUE%10;				
		}
		
		
		KeyScan();
		if(KEY_Value==7){KEY_Value=0;SEG_Run = 1 ;}
		if(KEY_Value==6){KEY_Value=0;SEG_Run = 0 ;}
		if(KEY_Value==5){KEY_Value=0;LEDx_ON(1);Buzzer_ON;}
		if(KEY_Value==4){KEY_Value=0;LEDx_OFF(1);Buzzer_OFF;}	
	}
}

void KeyScan(void)
{
	if(P30==0)
	{
		Delay_MS(10);
		if(P30==0)KEY_Value = 7 ;		
		while(!P30);
	}
	else if(P31==0)
	{
		Delay_MS(10);
		if(P31==0)KEY_Value = 6 ;		
		while(!P31);
	}	
	else if(P32==0)
	{
		Delay_MS(10);
		if(P32==0)KEY_Value = 5 ;		
		while(!P32);
	}	
	else if(P33==0)
	{
		Delay_MS(10);
		if(P33==0)KEY_Value = 4 ;		
		while(!P33);
	}	
}

void Timer0(void) interrupt 1
{
	P0=0X00;
	P2|=0XC0;  // P2=P2|0XC0;   XXXX XXXX | 1100 0000 = 11XX XXXX
	P2&=0XDF;	 // P2=P2&0XDF;   11XX XXXX & 1101 1111 = 110X XXXX	
	P2&=0X1F;		//关闭所有的74HC573锁存器	
	
	P0=tab[DigBuf[DigCom]];	
	P2|=0XE0;			//	P2=P2|0XE0;   XXXX XXXX | 1110 0000 = 111X XXXX
	P2&=0XFF;		 	// P2=P2&0XDF;   11XX XXXX & 1101 1111 = 110X XXXX	
	P2&=0X1F;			//关闭所有的74HC573锁存器
	
	P0=(0X01<<DigCom); 	//然后选中第一个数码管
	P2|=0XC0;  // P2=P2|0XC0;   XXXX XXXX | 1100 0000 = 11XX XXXX
	P2&=0XDF;	 // P2=P2&0XDF;   11XX XXXX & 1101 1111 = 110X XXXX	
	P2&=0X1F;		//关闭所有的74HC573锁存器

	if(++DigCom == 8)DigCom = 0 ;
	
	LED_tt++;
	if(LED_tt == 999) {LED_tt = 0 ; LED_Ref = 1 ;}

	if(++SEG_tt==1000){SEG_tt=0;SEG_Ref=1;}
	
	if(++AD_tt==500){AD_tt=0;AD_Ref=1;}
//	XXX_tt++;
//	if(++XXX_tt==NNN){XXX_tt=0;XXX_Ref=1;}	
}

void Timer0Init(void)		//1毫秒@11.0592MHz
{
	AUXR |= 0x80;		//定时器时钟1T模式
	TMOD &= 0xF0;		//设置定时器模式
	TL0 = 0xCD;		//设置定时初始值
	TH0 = 0xD4;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	TR0 = 1;		//定时器0开始计时
}



void Delay_MS(unsigned int MS)
{
	unsigned i,j;
	for(i=0;i<MS;i++)
		for(j=853;j>0;j--); //STC15单片机设置为853; STC8H单片机修改为1109；STC32G单片机修改为427;
}

void ALL_Init(void)
{
	P0 =0X00;		//先设置关闭蜂鸣器继电器的P0输出值（全关）
	P2|=0XA0;		// 将P27 P25 设置为1 其他位保持不变
	P2&=0XBF; 	// 将P26设置为0 其他位保持不变
	P2&=0X1F;		//关闭所有的74HC573锁存器

	P0 =0XFF;		//先设置关闭所有的LED的P0输出值（全关）
	P2|=0X80;		// 将P27设置为1 其他位保持不变
	P2&=0X9F;		// 将P26 P25设置为0 其他位保持不变
	P2&=0X1F;		//关闭所有的74HC573锁存器
	
	P0 =0X00;		//先设置选择数码管位选的P0输出值（全不选）
	P2|=0XC0;		// 将P27 P26 设置为1 其他位保持不变
	P2&=0XDF;		// 将P26设置为0 其他位保持不变
	P2&=0X1F;		//关闭所有的74HC573锁存器
}

void IO_Init(void)
{
	P0M0 = 0x00; 	P0M1 = 0x00; 			//IO初始化为准双向I/O模式，STC15F系列可以写
	P1M0 = 0x00; 	P1M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P2M0 = 0x00; 	P2M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P3M0 = 0x00; 	P3M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P4M0 = 0x00; 	P4M1 = 0x00;			//IO初始化为准双向I/O模式，STC15F系列可不写
	P0=0XFF; P1=0XFF; P2=0XFF; P3=0XFF; P4=0XFF; P5=0XFF; //P0、P1、P2、P3、P4、P5输出为高电平	 STC15系列单片机可不写
}

/*
void ArrKeyScan(void)
{
	unsigned char temp;				//定义局部变量用来存储从P3口读出的数值? 
	P44=0; P42=1; P3=0X7F; 		// //0111 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0X7E: KEY_Value = 7 ; break;
				case 0X7D: KEY_Value = 6 ; break;
				case 0X7B: KEY_Value = 5 ; break;
				case 0X77: KEY_Value = 4 ; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}
	
	P44=1; P42=0; P3=0XBF; 		// //0111 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0XBE: KEY_Value = 11 ; break;
				case 0XBD: KEY_Value = 10 ; break;
				case 0XBB: KEY_Value = 9 ; break;
				case 0XB7: KEY_Value = 8 ; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}

	P44=1; P42=1; P3=0XDF; 		// //1101 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0XDE: KEY_Value = 15 ; break;
				case 0XDD: KEY_Value = 14 ; break;
				case 0XDB: KEY_Value = 13 ; break;
				case 0XD7: KEY_Value = 12 ; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}
	
	P44=1; P42=1; P3=0XEF; 		// //0111 1111 扫描第一列
	temp = P3 ;								//将P3口读出的数字赋值给temp 
	temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
	if(temp != 0X0F)
	{
		Delay_MS(5);
		temp = P3 ;								//将P3口读出的数字赋值给temp 
		temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
		if(temp != 0X0F)
		{
			temp = P3 ;
			switch(temp)  //1110  1101 1011 0111 
			{
				case 0XEE: KEY_Value = 19 ; break;
				case 0XED: KEY_Value = 18 ; break;
				case 0XEB: KEY_Value = 17; break;
				case 0XE7: KEY_Value = 16; break;
				default :  break;
			}
			while(temp != 0X0F)
			{
				temp = P3 ;								//将P3口读出的数字赋值给temp 
				temp = temp & 0X0F ; 			// 0111 XXXX & 0000 1111 = 0000 XXXX 
			}
		}
	}
}
*/

2.iic.c文件


#include "reg52.h"
#include "intrins.h"

#define DELAY_TIME 5

#define SlaveAddrW 0xA0
#define SlaveAddrR 0xA1

//总线引脚定义
sbit SDA = P2^1;  /* 数据线 */
sbit SCL = P2^0;  /* 时钟线 */

void IIC_Delay(unsigned char i)
{
    do{_nop_();}
    while(i--);        
}
//总线启动条件
void IIC_Start(void)
{
    SDA = 1;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 0;
    IIC_Delay(DELAY_TIME);
    SCL = 0;	
}

//总线停止条件
void IIC_Stop(void)
{
    SDA = 0;
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

//发送应答
void IIC_SendAck(bit ackbit)
{
    SCL = 0;
    SDA = ackbit;  					// 0：应答，1：非应答
    IIC_Delay(DELAY_TIME);
    SCL = 1;
    IIC_Delay(DELAY_TIME);
    SCL = 0; 
    SDA = 1;
    IIC_Delay(DELAY_TIME);
}

//等待应答
bit IIC_WaitAck(void)
{
    bit ackbit;
	
    SCL  = 1;
    IIC_Delay(DELAY_TIME);
    ackbit = SDA;
    SCL = 0;
    IIC_Delay(DELAY_TIME);
    return ackbit;
}

//通过I2C总线发送数据
void IIC_SendByte(unsigned char byt)
{
    unsigned char i;

    for(i=0; i<8; i++)
    {
        SCL  = 0;
        IIC_Delay(DELAY_TIME);
        if(byt & 0x80) SDA  = 1;
        else SDA  = 0;
        IIC_Delay(DELAY_TIME);
        SCL = 1;
        byt <<= 1;
        IIC_Delay(DELAY_TIME);
    }
    SCL  = 0;  
}

//从I2C总线上接收数据
unsigned char IIC_RecByte(void)
{
    unsigned char i, da;
    for(i=0; i<8; i++)
    {   
    	SCL = 1;
	IIC_Delay(DELAY_TIME);
	da <<= 1;
	if(SDA) da |= 1;
	SCL = 0;
	IIC_Delay(DELAY_TIME);
    }
    return da;    
}

void AD_write(unsigned char dat)
{
	IIC_Start();
	IIC_SendByte(0X90);
	IIC_WaitAck();
	IIC_SendByte(0X40);
	IIC_WaitAck();
	IIC_SendByte(dat);
	IIC_WaitAck();
	IIC_Stop();
}

unsigned char AD_read(unsigned char add)
{
	unsigned char dat;
	
	IIC_Start();
	IIC_SendByte(0X90);
	IIC_WaitAck();
	IIC_SendByte(add);
	IIC_WaitAck();
	IIC_Stop();
	
	IIC_Start();
	IIC_SendByte(0X91);
	IIC_WaitAck();
	dat=IIC_RecByte();
	IIC_SendAck(1);
	IIC_Stop();
	
	return dat;
}

 3.IIC.H文件

#ifndef _IIC_H
#define _IIC_H

void IIC_Start(void); 
void IIC_Stop(void);  
bit IIC_WaitAck(void);  
void IIC_SendAck(bit ackbit); 
void IIC_SendByte(unsigned char byt); 
unsigned char IIC_RecByte(void); 

void AD_write(unsigned char dat);
unsigned char AD_read(unsigned char add);

#endif

吸尘器的灰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
CodeLab：Android fundamentals 07.2:AsyncTask and AsyncTaskLoader
qq_39040714的博客
04-12 743
Android fundamentals 07.2:AsyncTask and AsyncTaskLoader Tutorial source : Google CodeLab Date : 2021/04/06 Complete course : 教程目录 (java). Note : The link in this article requires Google access 1、Welcome This practical codelab is part of Unit 3: Working in
les-07.2
03-30
这个压缩包“les-07.2-master”可能是该课程或资源的源代码或课件主分支。 HTML知识点涵盖广泛，以下是一些主要的方面： 1. **HTML基本结构**：HTML文档通常以`<!DOCTYPE html>`开头，接着是`<html>`元素，它是...
dart 07.2 异步
Applicaton的专栏
06-19 203
Dart 异步 dart提供了Future 和Stream 对象来实现异步方案 future Future 是一个异步执行并且在未来的某一个时刻完成（或失败）的任务。 这意味着其结果将在未来某一个时刻准备好 当实例化一个Future时： 该 Future 的一个实例被创建并记录在由 Dart 管理的内部数组中； 需要由此 Future 执行的代码直接推送到 Event 队列中去； 该 future 实例 返回一个状态（= incomplete）； 如果任务正在event队列中等待，返回一个未完
07.2. 使用块的网络（VGG）
weixin_45063703的博客
10-09 156
使用块的想法首先出现在牛津大学的视觉几何组（visualgeometry group）的VGG网络中。不同的VGG模型可通过每个块中卷积层数量和输出通道数量的差异来定义。原始VGG网络有5个卷积块，其中前两个块各有一个卷积层，后三个块各包含两个卷积层。一个VGG块与之类似，由一系列卷积层组成，后面再加上用于空间下采样的最大汇聚层。在下面的代码中，我们定义了一个名为vgg_block的函数来实现一个VGG块。开始从单个神经元的角度思考问题，发展到整个层，现在又转向块，重复层的模式。
07.2 python基础-类属性和方法
qq_25672165的博客
03-27 118
07.1.1 类对象 类对象支持两种操作：属性引用和实例化 # 类定义 class MyClass: """一个简单的类实例""" i = 12345 def f(self): return 'hello world' # 实例化类 x = MyClass() # 访问类的属性和方法 print("MyClass 类的属性 i 为：", x....
飞雨工作室网站源码 v.07.2
03-25
一套理想的工作室类网站程序，后台功能列表有：企业信息，产品管理，订单管理，下载中心，会员管理，新闻管理，留言管理，人才管理等。 登录地址：/admin/login.asp 用户：admin ...适合用于企业网站，工作室团队类的...
07.2-CTC模式实验[整理].pdf
10-10
07.2-CTC模式实验[整理].pdf
ISTrd0055v001(IST5001) 07.2.27
02-16
ISTrd0055v001(IST5001) 07.2.27
07.2、程序：FreeRTOS+LCD全功能.zip
05-16
在本项目"07.2、程序：FreeRTOS+LCD全功能.zip"中，我们重点关注的是如何在STM32微控制器上使用FreeRTOS操作系统来驱动LCD显示屏，实现丰富的图形和文字显示功能。FreeRTOS是一个轻量级、实时的操作系统，适用于资源...
树莓派开发相关知识二
最新发布
weixin_45114627的博客
08-14 123
无论是哪种模式，明明按了1次，却输出很多次，这是为什么呢？实际上，按键按下的一瞬间，会有多个脉冲，故会判定多次按下，需要通过代码进行防抖。由程控自由使用，PIN脚依现实考量可作为通用输入（GPI）或通用输出（GPO）或通用输入与输出（GPIO）。树莓派装载的芯片：BCM2835是一个MCU微处理器，它可以理解为CPU+其它模块的组合。编程使用时，需要导入RPI包中的GPIO模块， as 将此导入的结果用GPIO表示。GPIO输入：就是输入一个电压信号，可以理解为开关打开后电流可以注入的端口。
江科大/江协科技 STM32学习笔记P20
sususu_2001的博客
08-07 936
编码器接口的初始化，第一步，RCC开启时钟，开启GPIO和定时器的时钟，第二步，配置GPIO，这里把PA6和PA7配置成输入模式，第三步，配置时基单元，这里预分频器选择不分频，自动重装寄存器给最大65535，第四步，配置输入捕获单元，只有滤波器和极性选择有用，第五步，配置编码器接口模式，最后，调用TIM_Cmd，启动定时器。
【屏驱MCU】实现文件路径的的挂载
欢迎私信、留言交流
08-14 349
【屏驱MCU】实现文件路径的的挂载
STM32&低功耗与备用备份区域
wwwkkkxxx12138的博客
08-14 956
平常的手机手表为什么可以等为什么可以长时间待机？嵌入式开发板做出的东西能不能也低功耗？复位后数据如很能不丢失？来解决解决
定时器介绍
m0_68615655的博客
08-14 165
【代码】定时器介绍。
【屏显MCU】内存使用总结（二）
欢迎私信、留言交流
08-14 101
> 本文主要介绍 屏显 `MCU` 的内存 > 以下是以屏显` MCU` 的文章系列
【屏驱MCU】系列文章合集
欢迎私信、留言交流
08-14 125
【屏驱MCU】系列文章合集，文章跳转界面
可调恒流电子负载如何实现的
SHANGHAIWENSHUN的博客
08-14 247
保护电路的工作原理是：当输出电流超过设定值时，保护电路会通过比较器，判断出过载情况，然后通过继电器或MOSFET，切断电源，保护设备和负载的安全。
基于单片机控制的多功能智能语音风扇
weixin_45905610的博客
08-14 373
本文简述了一种基于单片机控制的智能多功能语音风扇的设计，该设计以STC11L08XE单片机为主控制器，通过YS-LDV7语音模块对语音信号进行采集识别，并将该信号上传给单片机进而控制风扇的转速和开关，以达到语音控制的效果。该设计还装有温度传感器和时钟芯片，通过LCD12864液晶显示室内的温度、时间等相关的工作参数，以达人机交互和多功能的目的。
printf("b=%07.2f\n,b")什么意思
03-04
这段代码是使用C语言中的printf函数来打印一个格式化的输出。其中，"\u0007"代表ASCII控制字符"BEL"，它会发出一个嗡嗡的响声。".2f"表示要输出一个浮点数，并保留两位小数。"%f"是格式化输出浮点数的占位符。"\\n"代表换行符，用于将输出移到下一行。 所以，该代码的输出结果将是打印出一个带有嗡嗡声的浮点数b，并且保留两位小数，最后换行。请注意，代码中的变量b并没有被定义或初始化，所以实际上并不能输出一个有效的值。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值