STM32软件模拟串口的实现-基于CrubeMX

最新推荐文章于 2024-08-11 19:58:34 发布
最新推荐文章于 2024-08-11 19:58:34 发布
阅读量2.3k 收藏 14
点赞数 4
分类专栏： STM32快速学习手册 文章标签： stm32 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dh1151313194/article/details/112836117
版权

前言：最近芯片涨价还缺货，寻找替换方案是目前的解决办法，对于串口不够用的时候，可以考虑软件模拟方案。

一 原理讲解

本文代码：
https://gitee.com/caledonian_study/stm32-l431_-virtual-serial

1.1首先读模拟串口读前文档，
http://news.eeworld.com.cn/mcu/2018/ic-news082740999.html
https://blog.csdn.net/tonyiot/article/details/82502953https://www.cnblogs.com/wangshucai/p/10817204.html
https://my.st.com/content/my_st_com/en/products/embedded-software/mcu-mpu-embedded-software/stm32-embedded-software/stm32-standard-peripheral-library-expansion/stsw-stm32156.html#documentation
https://www.amobbs.com/thread-5704405-1-1.html?_dsign=cc2ca849
明白模拟串口怎么实现。用到的外设有普通gpio，外部中断，定时器。 本程序的代码在：

1.2 发送

串口发送每一个字节时候，每一个比特位占用多少时间， 如：波特率是38400，

  1. 一秒钟发送38400的比特位的数据，
  2. 每个字节占用10个比特位（1位起始位，8位数据位，无奇偶校验，1位停止位，）
  3. 每秒发送3840个字节， 每个比特位占用的时间是：1/38400秒= 26.04us

要实现一个us的延时函数，ST的HALL库默认是ms延时，这里在网上搜集了一下，用定时器实现us延时函数，顺便实现ms延时函数。

参考文章：
STM32F407 使用HAL库延时微妙实现方法（附CubeMX配置过程）
注意：这里要说明一下，HALL库的延时函数是在systick中断里面每ms加1s，没有延时的时候中断没有关闭，导致系统资源浪费。 正确的应该是给定时器1计数设置一个初始值，硬件自动加数，在delay里面读计数值，比如L431系统时钟是80MHz，定时器的配置如下：
在这里插入图片描述

定时器1每加1，时间是1us，我要延时26us，那我就再delay里面一直读定时器的CNT寄存器值是不是大于26。

1.3 接收

接收数据的时候，下降沿激发产生外部中断事件，开启定时器2。每隔一段时间读取一下gpio引脚的电平状态，保存在临时数组，到停止位则一个字节数据接收完成，读取字节数据，放在全局256大小的缓冲区。
在这里插入图片描述

注意：这里读取GPIo引脚的状态，应该在每个bit位的1/2读取GPIO的状态，这样读取的数据比较准确。
在这里插入图片描述

1.4 数据分包
有没有考虑过一个问题，怎么样收一包数据？ 这里有个数据分包的问题，数据分包是这样的，我在数据停止位拿到数据以后，吧定时器2中断时间延长，我定义了两包数据之间的间隔大于100us，这里有两种情况：

  1. 后续没有数据到来，自然会进入到定时器2的分包处理流程。
  2. 后续有数据到来，外部中断重新设置定时器2时间。

二 crubeMX配置

2.1 GPIO配置

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

2.2 定时器2中断，外部中断
在这里插入图片描述

2.3 定时器1配置
在这里插入图片描述

2.4 定时器2配置
在这里插入图片描述

配置好后生成工程

三 代码

3.1 修改tim.c

实现定时器初始化，delay_ms()，delay_us()，定时器2回调

/* Includes ------------------------------------------------------------------*/
#include "tim.h"

/* USER CODE BEGIN 0 */
#include "myusart_RX.h"
/* USER CODE END 0 */

TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim2;

/* TIM1 init function */
void MX_TIM1_Init(void)
{
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 80-1;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 1;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }

}
/* TIM2 init function */
void MX_TIM2_Init(void)
{
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 8-1;
  htim2.Init.CounterMode = TIM_COUNTERMODE_DOWN;
  htim2.Init.Period = 130;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }

}

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM1)
  {
  /* USER CODE BEGIN TIM1_MspInit 0 */

  /* USER CODE END TIM1_MspInit 0 */
    /* TIM1 clock enable */
    __HAL_RCC_TIM1_CLK_ENABLE();
  /* USER CODE BEGIN TIM1_MspInit 1 */

  /* USER CODE END TIM1_MspInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM2)
  {
  /* USER CODE BEGIN TIM2_MspInit 0 */

  /* USER CODE END TIM2_MspInit 0 */
    /* TIM2 clock enable */
    __HAL_RCC_TIM2_CLK_ENABLE();

    /* TIM2 interrupt Init */
    HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(TIM2_IRQn);
  /* USER CODE BEGIN TIM2_MspInit 1 */

  /* USER CODE END TIM2_MspInit 1 */
  }
}

void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{

  if(tim_baseHandle->Instance==TIM1)
  {
  /* USER CODE BEGIN TIM1_MspDeInit 0 */

  /* USER CODE END TIM1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM1_CLK_DISABLE();
  /* USER CODE BEGIN TIM1_MspDeInit 1 */

  /* USER CODE END TIM1_MspDeInit 1 */
  }
  else if(tim_baseHandle->Instance==TIM2)
  {
  /* USER CODE BEGIN TIM2_MspDeInit 0 */

  /* USER CODE END TIM2_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM2_CLK_DISABLE();

    /* TIM2 interrupt Deinit */
    HAL_NVIC_DisableIRQ(TIM2_IRQn);
  /* USER CODE BEGIN TIM2_MspDeInit 1 */

  /* USER CODE END TIM2_MspDeInit 1 */
  }
}

下面是自己加的

/* USER CODE BEGIN 1 */

//实现微妙延时功能
void delay_us(uint16_t us)
{
    uint16_t differ=0xffff-us-5;
HAL_TIM_Base_Start(&htim1);//打开定时器
    __HAL_TIM_SetCounter(&htim1,differ);//设置计数初始值
    while(differ < 0xffff-5)
    {
        differ = __HAL_TIM_GetCounter(&htim1);//拿到计数值
    }
    HAL_TIM_Base_Stop(&htim1);//关闭定时器
}
void delay_ms(uint16_t ms)
{
	for(uint16_t i=0;i<ms;i++)
	{
	delay_us(1000);
	}
}	

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* tim_baseHandle)
{
	if(tim_baseHandle->Instance == htim2.Instance)
	{
		TIM2_IRQHandlerHandle();
	}
	
}
/* USER CODE END 1 */

3.2 修改gpio.c
实现引脚初始化，外部中断回调


#include "gpio.h"

/* USER CODE BEGIN 0 */
#include "myusart_RX.h"
/* USER CODE END 0 */

/*----------------------------------------------------------------------------*/
/* Configure GPIO                                                             */
/*----------------------------------------------------------------------------*/
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/** Configure pins
*/
void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(usart_tx_GPIO_Port, usart_tx_Pin, GPIO_PIN_SET);

  /*Configure GPIO pin : PtPin */
  GPIO_InitStruct.Pin = usart_tx_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(usart_tx_GPIO_Port, &GPIO_InitStruct);

  /*Configure GPIO pin : PtPin */
  GPIO_InitStruct.Pin = usart_rx_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(usart_rx_GPIO_Port, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI15_10_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);

}

下面是自己加的

/* USER CODE BEGIN 2 */
/**
 * @brief	EXIT中断回调函数
 * @param GPIO_Pin —— 触发中断的引脚
 * @retval	none
*/
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	/* 判断哪个引脚触发了中断 */
	switch(GPIO_Pin)
	{
		case usart_rx_Pin:
			 GPIO_A_10_CALLBACK();
			break;
		case GPIO_PIN_3:
break;
		default:
			break;
	}
}
/* USER CODE END 2 */

3.3 增加myusart_TX.c
实现发射功能



#include "myusart_TX.h"
#include "gpio.h"
#include "core_cm4.h" 
#include "tim.h"
#define BuadRate_9600	100
#define BuadRate_38400	26
void delay_tx(void)//26.04us
{
delay_us(BuadRate_38400-1);
	//补偿
__NOP();
	__NOP();
	__NOP();
	__NOP();
	__NOP();
	__NOP();
	__NOP();
	__NOP();
	__NOP();
	__NOP();
	__NOP();
}
void IO_TXD(uint8_t Data)
{
	uint8_t i = 0;
	HAL_GPIO_WritePin(usart_tx_GPIO_Port, usart_tx_Pin, GPIO_PIN_RESET);
	delay_tx();
	for(i = 0; i < 8; i++)
	{
		if(Data&0x01)
		HAL_GPIO_WritePin(usart_tx_GPIO_Port, usart_tx_Pin, GPIO_PIN_SET);
		else
		HAL_GPIO_WritePin(usart_tx_GPIO_Port, usart_tx_Pin, GPIO_PIN_RESET);
		delay_tx();
		Data = Data>>1;
	}
		HAL_GPIO_WritePin(usart_tx_GPIO_Port, usart_tx_Pin, GPIO_PIN_SET);
		delay_tx();
}
//定义的发送函数
void USART_Send(uint8_t *buf, uint8_t len)
{
	uint8_t t;
	for(t = 0; t < len; t++)
	{
		IO_TXD(buf[t]);
	}
}
char *p="okokokokok";
void test_TX()
{
USART_Send((uint8_t *)p,10);
 delay_ms(500);
}

3.4 增加myusart_TX.h

#ifndef __myusart_TX_H__
#define __myusart_TX_H__
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "main.h"
void test_TX(void);
void USART_Send(uint8_t *buf, uint8_t len);
#ifdef __cplusplus
}
#endif
#endif /*__ GPIO_H__ */

3.5 增加myusart_RX.c

#include "myusart_RX.h"
#include "myusart_TX.h"
#include "gpio.h"
#include "core_cm4.h" 
#include "tim.h"
#define BuadRate_9600	100
#define BuadRate_38400	26
#define UsartPack_delay	 1000//100us
uint8_t len = 0;	//接收了多少个字节
uint8_t USART_buf[256];  //接收缓冲区
uint8_t DateReceiveIsOK=0;//接收到数据标志
uint8_t len8buf = 0;	
uint8_t USART_8buf[20];
enum{
	COM_START_BIT_NOP,
	COM_START_BIT,
	COM_D0_BIT_NOP,
	COM_D0_BIT,
	COM_D1_BIT_NOP,
	COM_D1_BIT,
	COM_D2_BIT_NOP,
	COM_D2_BIT,
	COM_D3_BIT_NOP,
	COM_D3_BIT,
	COM_D4_BIT_NOP,
	COM_D4_BIT,
	COM_D5_BIT_NOP,
	COM_D5_BIT,
	COM_D6_BIT_NOP,
	COM_D6_BIT,
	COM_D7_BIT_NOP,
	COM_D7_BIT,
	COM_STOP_BIT,
	
	COM_pack_delay,
};
uint8_t recvStat = COM_STOP_BIT;
uint8_t recvData = 0;
/********************************TX*********************************/
void TIM2_IRQHandlerHandle(void)
{  
		recvStat++;
		if(HAL_GPIO_ReadPin(usart_rx_GPIO_Port,usart_rx_Pin))
		{
				USART_8buf[len8buf++]=1;
		}else{
			  USART_8buf[len8buf++]=0;
		}	
			
		if(recvStat == COM_STOP_BIT)
		{
			//
			for(uint8_t i=1;i<9;i++ )
			{
				
				if(USART_8buf[2*i])//2 4 6  8 10 12 14 16
				{
					recvData |= (1 << (i - 1));
				}else{
					recvData &= ~(1 << (i - 1));
				}	
			
			}
			
			USART_buf[len++] = recvData;	
			
			//收到一个字节，吧定时器的中断  延长到UsartPack_delay us
			__HAL_TIM_SetCounter(&htim2, 10*UsartPack_delay);
			__HAL_TIM_SET_AUTORELOAD(&htim2, 10*UsartPack_delay);
			return;
		}else if(recvStat >= COM_pack_delay)//分包处理
		{
			//关闭定时器中断
			HAL_TIM_Base_Stop_IT(&htim2);
			//吧定时器时间调整到原来的13us
			__HAL_TIM_SET_AUTORELOAD(&htim2, 10* BuadRate_38400/2);//定时器13us来一次中断
			__HAL_TIM_SetCounter(&htim2, 10* BuadRate_38400/2);//定时器计数初始值130
			//关闭定时器
			__HAL_RCC_TIM2_CLK_DISABLE();
			DateReceiveIsOK=1;
			return;
		}
		
}

void GPIO_A_10_CALLBACK(void)
{
	if(HAL_GPIO_ReadPin(usart_rx_GPIO_Port,usart_rx_Pin) == 0) //判断是低电平
		{
			if((recvStat == COM_STOP_BIT)||(recvStat == COM_pack_delay))
			{
				//变量清0
				recvStat = COM_START_BIT_NOP;
				len8buf=0;
				//启动定时器
				__HAL_TIM_SET_AUTORELOAD(&htim2, 10*BuadRate_38400/2);//定时器计数初始值130
					__HAL_TIM_SetCounter(&htim2, 10* BuadRate_38400/2);//定时器13us来一次中断
				__HAL_RCC_TIM2_CLK_ENABLE();
				HAL_TIM_Base_Start_IT(&htim2);
			}
		}
}
/*******************************************************************************/
void test_rx()
{
		if(DateReceiveIsOK == 1)
		{
			
			USART_Send(USART_buf,len);
			len = 0;
			DateReceiveIsOK=0;
		}
}

3.6 增加myusart_RX.h

#ifndef __myusart_RX_H__
#define __myusart_RX_H__
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "main.h"
void test_rx(void);
void GPIO_A_10_CALLBACK(void);
void TIM2_IRQHandlerHandle(void);
#ifdef __cplusplus
}
#endif
#endif /*__ GPIO_H__ */

3.7 main.c

/* USER CODE BEGIN Includes */
#include "myusart_RX.h"
#include "myusart_TX.h"
/* USER CODE END Includes */
  while (1)
  {
    /* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
//	test_TX();
		test_rx();
  }
小男孩和胖子
关注
专栏目录
stm32软件模拟串口
09-25
stm32软件串口
软件模拟串口
03-19
只需一个定时器能模拟2个全双工通信串口 具有很强的滤波效果
【基于STM32的串口通信----用软件模拟】
嵌入式学习之路
06-10 6473
基于STM32的串口通信----用软件模拟
零基础STM32单片机编程入门(三十) USB口介绍及CDC类虚拟串口通讯详解及源码
最新发布
光子物联
08-11 2449
本文介绍了STM32单片机USB口的基本概念，内部结构，以及用USB虚拟串口进行数据通讯的例程。
STM32 freertos 使用软件模拟串口uart
mainbanp
01-23 1913
通过上面学习使用方法与故障排除，STM32 freertos 使用软件模拟串口uart已经正常可以使用了。通过这个测试也对freertos 有了进一步认识。
IO口软件模拟串口
深圳五月花--老李的森林
05-25 7843
嵌入式工程师经常会遇到系统资源不够的情况，比如我就遇到了串口不够，但IO引脚和定时器还富余，这时就可以通过模拟方式来扩展出一个串口。 这个方法适用于所有嵌入式系统，但是要注意，对于速度不要设置得太高，尽量不要高于9600。否则，当串口所用到的资源优先级不够高，而系统又很繁忙的时候，容易丢失数据或出错。 软件IIC是同样的道理，用软件模拟相关时序，但是IIC对时序要求不高，相对容易 串口时序 先说一下串口的时序，用得最多的就是9600，8，N，1，解释一下： 起始位1，在配置描述中中省略，低电平。 9600是
基于STM32F103C8T6开发板的模拟串口程序
04-27
该程序是在stm32f103c8t6开发板上进行开发，其中使用的软件是MDK5，程序经过测试，运行成功
STM32软件模拟I2C从机的例程代码
05-03
STM32软件模拟I2C从机的实现方法，使用GPIO来模拟I2C从机通信，对于GPIO可以配置边沿中断的MCU来说，也可参照该例程代码来实现软件模拟I2C从机。本例程代码对应的说明文章可以关注”固件工人“微信公众号，搜索《STM...
高级例程-基于STM32 USB 虚拟串口 控制IO 端口_基于STM32USB虚拟串口控制_
09-30
虚拟串口是通过USB接口模拟标准串行通信的一种技术，它使得用户可以通过电脑的COM口与STM32进行数据交互，而无需额外的硬件串口。在STM32中，我们需要配置USB设备控制器，使其工作在CDC (Communication Device Class...
stm32-基于STM32F103的移动底座与ROS通信-包括ROS串口节点+STM32串口转发-项目源码-优质嵌入式项目分享
04-19
本文将详细讲解基于STM32F103的移动底座如何与ROS（Robot Operating System）进行通信，以及其中涉及的关键技术，包括ROS串口节点和STM32串口转发。这个优质嵌入式项目提供了丰富的源码资源，有助于开发者深入理解和...
基于STM32烟雾传感器.zip_stm32-_基于stm32 mq-2_烟雾_烟雾 stm32_烟雾基于STM32
07-14
本项目着重讲解如何利用STM32微控制器和MQ-2烟雾传感器构建一个烟雾检测系统，通过ADC（模拟数字转换器）读取传感器数据，实现对环境烟雾浓度的实时监测。 **一、STM32微控制器基础** STM32是意法半导体...
单片机软件模拟串口收发
06-13
单片机软件模拟串口收发，当串口端口不够使用的时候，可以采用软件模拟时序的方式实现串口功能
STM32F103 虚拟串口程序
10-23
STM32F103 虚拟串口程序，原子开发板改编可以使用欢迎大家下载。
stm32f103zet6普通IO口模拟串口
03-13
由于STM32串口有限，于是试着将普通IO口模拟成串口使用，本来想着挺难，后来只要搞清楚串口的时序其实就很简单了，测试成功，附上MDK工程。
模拟串口工具
07-20
模拟串口工具，在windows系统下安装，可以自动生成模拟串口，方便测试基于串口开发的软件。
STM32 GPIO和定时器 模拟串口
08-08
基于STM32F042,使用定时器 GPIO模拟串口，定时器自动发送数据，发送不会一直不占用CPU
stm32软件串口1.0.zip_STM32 IO模拟_stm32 串口_stm32 模拟串口_串口 STM32_模拟串口 S
07-15
通过stm32 io口模拟串口,串口接收通过中断. 本代码会把发送给串口的数据,发送出来
STM32模拟串口总结
1
03-26 2141
STM32模拟串口总结 发送端的方法 1.纯延时模拟 此方法延时精确度不够，或者发送前必须关中断 void IO_TXD(u8 ch) { u8 i = 0; GPIO_ResetBits(GPIOB,GPIO_Pin_0); delay_us(BuandRate); //延时的时间 for(i = 0; i < 8; i++) { if(ch&0x01) GPIO_SetBits(GPIOB,GPIO_Pin_0); el
单片机软件模拟串口
weixin_47768836的博客
01-18 8244
单片机IO模拟串口通信(收发）
STM32软件模拟I2C实现与问题解决
STM32微控制器的内置硬件IIC接口在某些情况下可能会遇到稳定性问题或者使用不便，因此，开发者通常会选择使用软件模拟IIC（Inter-Integrated Circuit）的方式来实现I2C通信。这种方式虽然比硬件IIC需要更多的CPU资源...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小男孩和胖子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值