基于STM32F4的CAN通信例程(库函数版)

已于 2023-09-08 11:29:41 修改
阅读量2.1k 收藏 20
点赞数 8
文章标签： stm32 嵌入式硬件 单片机
于 2023-09-08 10:00:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41044925/article/details/132753385
版权

一、介绍

  实现STM32的CAN通信的时候，我们无需关注本身复杂的CAN通信协议许多细枝末节的东西已经被厂商封装起来，我们可以先让程序跑起来，再通过调整各个参数来熟悉STM32中的CAN通信的原理。

  实现CAN通信与实现SPI、I2C、串口等通信并无二致，都是先初始化引脚、片上外设、中断处理。然后在主函数中调用初始化，接着就可以当作通信使用，任何通信本质上都是接收receive)和发送(transmit).

  STM32中的CAN接收发送原型库函数。

uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage)
{
  uint8_t transmit_mailbox = 0;
  /* Check the parameters */
  assert_param(IS_CAN_ALL_PERIPH(CANx));
  assert_param(IS_CAN_IDTYPE(TxMessage->IDE));
  assert_param(IS_CAN_RTR(TxMessage->RTR));
  assert_param(IS_CAN_DLC(TxMessage->DLC));

  /* Select one empty transmit mailbox */
  if ((CANx->TSR&CAN_TSR_TME0) == CAN_TSR_TME0)
  {
    transmit_mailbox = 0;
  }
  else if ((CANx->TSR&CAN_TSR_TME1) == CAN_TSR_TME1)
  {
    transmit_mailbox = 1;
  }
  else if ((CANx->TSR&CAN_TSR_TME2) == CAN_TSR_TME2)
  {
    transmit_mailbox = 2;
  }
  else
  {
    transmit_mailbox = CAN_TxStatus_NoMailBox;
  }

  if (transmit_mailbox != CAN_TxStatus_NoMailBox)
  {
    /* Set up the Id */
    CANx->sTxMailBox[transmit_mailbox].TIR &= TMIDxR_TXRQ;
    if (TxMessage->IDE == CAN_Id_Standard)
    {
      assert_param(IS_CAN_STDID(TxMessage->StdId));  
      CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->StdId << 21) | \
                                                  TxMessage->RTR);
    }
    else
    {
      assert_param(IS_CAN_EXTID(TxMessage->ExtId));
      CANx->sTxMailBox[transmit_mailbox].TIR |= ((TxMessage->ExtId << 3) | \
                                                  TxMessage->IDE | \
                                                  TxMessage->RTR);
    }
    
    /* Set up the DLC */
    TxMessage->DLC &= (uint8_t)0x0000000F;
    CANx->sTxMailBox[transmit_mailbox].TDTR &= (uint32_t)0xFFFFFFF0;
    CANx->sTxMailBox[transmit_mailbox].TDTR |= TxMessage->DLC;

    /* Set up the data field */
    CANx->sTxMailBox[transmit_mailbox].TDLR = (((uint32_t)TxMessage->Data[3] << 24) | 
                                             ((uint32_t)TxMessage->Data[2] << 16) |
                                             ((uint32_t)TxMessage->Data[1] << 8) | 
                                             ((uint32_t)TxMessage->Data[0]));
    CANx->sTxMailBox[transmit_mailbox].TDHR = (((uint32_t)TxMessage->Data[7] << 24) | 
                                             ((uint32_t)TxMessage->Data[6] << 16) |
                                             ((uint32_t)TxMessage->Data[5] << 8) |
                                             ((uint32_t)TxMessage->Data[4]));
    /* Request transmission */
    CANx->sTxMailBox[transmit_mailbox].TIR |= TMIDxR_TXRQ;
  }
  return transmit_mailbox;
}
void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage)
{
  /* Check the parameters */
  assert_param(IS_CAN_ALL_PERIPH(CANx));
  assert_param(IS_CAN_FIFO(FIFONumber));
  /* Get the Id */
  RxMessage->IDE = (uint8_t)0x04 & CANx->sFIFOMailBox[FIFONumber].RIR;
  if (RxMessage->IDE == CAN_Id_Standard)
  {
    RxMessage->StdId = (uint32_t)0x000007FF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 21);
  }
  else
  {
    RxMessage->ExtId = (uint32_t)0x1FFFFFFF & (CANx->sFIFOMailBox[FIFONumber].RIR >> 3);
  }
  
  RxMessage->RTR = (uint8_t)0x02 & CANx->sFIFOMailBox[FIFONumber].RIR;
  /* Get the DLC */
  RxMessage->DLC = (uint8_t)0x0F & CANx->sFIFOMailBox[FIFONumber].RDTR;
  /* Get the FMI */
  RxMessage->FMI = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDTR >> 8);
  /* Get the data field */
  RxMessage->Data[0] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDLR;
  RxMessage->Data[1] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 8);
  RxMessage->Data[2] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 16);
  RxMessage->Data[3] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDLR >> 24);
  RxMessage->Data[4] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONumber].RDHR;
  RxMessage->Data[5] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 8);
  RxMessage->Data[6] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 16);
  RxMessage->Data[7] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONumber].RDHR >> 24);
  /* Release the FIFO */
  /* Release FIFO0 */
  if (FIFONumber == CAN_FIFO0)
  {
    CANx->RF0R |= CAN_RF0R_RFOM0;
  }
  /* Release FIFO1 */
  else /* FIFONumber == CAN_FIFO1 */
  {
    CANx->RF1R |= CAN_RF1R_RFOM1;
  }
}

使用它们时就是初始化参数，赋值参数然后调用函数。将以上步骤封装为函数。

二、完整代码

can.h

#ifndef __STM32_CAN_H_
#define __STM32_CAN_H_

#include "stm32f4xx.h"


#define CAN_RX_INT_CONFIG 1 //配置CAN接收中断结构体

void CanTransPort_Init(void);

uint8_t sendMsgToCan(CanTxMsg *msg,uint8_t *data);//发送报文
uint16_t CanRecMsg(uint8_t *msg); 	//接收报文



#endif

 can.c

#include "stm32_can.h"
#include "usart.h"

CanRxMsg rxMessage;
CanTxMsg txMessage;

void CanTransPort_Init(void)
{
	GPIO_InitTypeDef 			 GPIO_InitStructure;		//GPIO物理接口
	CAN_InitTypeDef        CAN_InitStructure;	//CAN外设初始结构体	规定CAN通信速率 策略
	CAN_FilterInitTypeDef  CAN_FilterInitStructure;	//CAN过滤器结构体 用于控制收发报文
	
#if CAN_RX_INT_CONFIG
	NVIC_InitTypeDef NVIC_InitStructure;
#endif
	//PD0 RX PD1 TX
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1,ENABLE);
	
	GPIO_PinAFConfig(GPIOD,GPIO_PinSource0,GPIO_AF_CAN1);
	GPIO_PinAFConfig(GPIOD,GPIO_PinSource1,GPIO_AF_CAN1);
	
	//Configure CAN1 TX
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_1;
	GPIO_InitStructure.GPIO_PuPd=GPIO_PuPd_UP;
	GPIO_InitStructure.GPIO_OType=GPIO_OType_PP;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed=GPIO_Fast_Speed;
	
	GPIO_Init(GPIOD,&GPIO_InitStructure);
	
	//Configure CAN1 RX
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF;
	GPIO_Init(GPIOD,&GPIO_InitStructure);
	
	//CAN外设初始化
	CAN_DeInit(CAN1);
	CAN_StructInit(&CAN_InitStructure);
	
	CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;
	CAN_InitStructure.CAN_ABOM=ENABLE; //自动离线管理
	CAN_InitStructure.CAN_AWUM=ENABLE;	//自动唤醒
	//42MHZ / (1+4+2)/ 12 = 500kbps
	CAN_InitStructure.CAN_BS1=CAN_BS1_4tq;
	CAN_InitStructure.CAN_BS2=CAN_BS2_2tq;
	CAN_InitStructure.CAN_SJW=CAN_SJW_2tq;
	CAN_InitStructure.CAN_Prescaler=12;
	CAN_InitStructure.CAN_RFLM=DISABLE; //锁定模式
	CAN_InitStructure.CAN_NART=DISABLE; //自动重传
	CAN_InitStructure.CAN_TTCM=DISABLE; //时间触发模式
	CAN_InitStructure.CAN_TXFP=DISABLE; //报文发送优先级判定方法
	
	CAN_Init(CAN1,&CAN_InitStructure);
	
	//CAN过滤器初始化
	CAN_FilterInitStructure.CAN_FilterNumber=0;
	CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
	CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FilterFIFO0; //安装过滤器
	CAN_FilterInitStructure.CAN_FilterIdHigh=0x00000000;
	CAN_FilterInitStructure.CAN_FilterIdLow=0x0000000;
	CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
	CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;	//过滤器使能
	
	CAN_FilterInit(&CAN_FilterInitStructure);
	
#if CAN_RX_INT_CONFIG
	NVIC_InitStructure.NVIC_IRQChannel=CAN1_RX0_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0x01;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=0x00;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_Init(&NVIC_InitStructure);
	CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);
#endif

}
uint8_t Can_ReceiveMsg(uint8_t *MsgBuffer)
{
	uint32_t i;
	CanRxMsg rxMsg;
	if(CAN_MessagePending(CAN1,CAN_FIFO0) == 0 ) return 0;
	CAN_Receive(CAN1,CAN_FIFO0,&rxMsg);
	for(i=0;i<8;i++)
	MsgBuffer[i] = rxMsg.Data[i];
	return rxMsg.DLC;
	
}

#if CAN_RX_INT_CONFIG

void CAN1_RX0_IRQHandler(void)
{	
	printf("enter CAN1_RX0_IRQHandler \r\n");
//	if(CAN_GetFlagStatus(CAN1,CAN_IT_FMP0) != RESET)		//添加中断会发送程序会死循环在中断里
//	{
			CAN_Receive(CAN1,CAN_FIFO0,&rxMessage);
			printf("Data:%s\r\n",rxMessage.Data);
			printf("ExtId:%d\r\n",rxMessage.ExtId);
//		CAN_ClearITPendingBit(CAN1,CAN_IT_FMP0);
//	}
	printf("exti CAN1_RX0_IRQHandler \r\n");
}

#endif

uint8_t sendMsgToCan(CanTxMsg *msg,uint8_t *data)
{
	uint16_t i = 0;
	uint8_t mailBox;
	msg->ExtId=0x1e2c;
	msg->IDE=CAN_Id_Extended;
	msg->RTR=CAN_RTR_Data;
	msg->DLC=8;
	
	for(i = 0;i<8;i++)
	{
		msg->Data[i] = data[i];
	}
	i=0;
	mailBox = CAN_Transmit(CAN1,msg);
	while(CAN_TransmitStatus(CAN1,mailBox) !=CAN_TxStatus_Ok && i <= 2000)
	{
		i++;
	}
	if(i >= 2000)
	{
		return 1;
	}
	else 
		return 0;
}

在主函数中使用CAN通信

main.c

#include "stm32f4xx.h"
#include "usart.h"
#include "delay.h"
#include "stm32_can.h"

extern CanRxMsg rxMessage;
extern CanTxMsg txMessage;

int main(void)
{	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	uint8_t txBuf[8];
	CanTransPort_Init();
	usart2_init(115200);
	delay_init(168);
	uint8_t i = 0;
	uint8_t cnt = 0;
	txBuf[0]=0x0e;
	txBuf[1]=0x1c;
	txBuf[2]=0xee;
	txBuf[3]=0xb0;
	txBuf[4]=0xe7;
	txBuf[5]=0xa1;
	txBuf[6]=0x99;
	txBuf[7]=0x35;
	
	USART2_printf("传输开始!\r\n");
	
	while(1)
	{
//		CanSendMsg(txBuf,8,0x00000000);
		sendMsgToCan(&txMessage,txBuf);
		txBuf[i]++;
		i++;
		if(i%8 == 0)
		{
			i = 0;
			cnt++;
		}
		if(cnt%4 == 0)
		{
			cnt = 0;
			for(i=0;i<8;i++)
			{
				txBuf[i]-=0x1F;
			}
			i=0;
		}
		delay_ms(2000);
		
	}
}

三、实验设备:

usart 转 CAN USB模块

STM32 F407

can硬件电路

四、实验现象

五、发送特定报文

查阅Ascii码表 

发送: 48 65 6C 6C 6F 43 61 6E 

对应: H  e     l    l     o   C   a  n

实验现象:

上位机

串口接收

六、工程代码地址

ZzlYang/STM32F4_CAN_Example: STM32F407 can example with usart_can model (github.com)

qq_41044925
关注
  • 8
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基础例程-CAN1与CAN2通讯.zip_CAN1 CAN2 通讯_CAN1CAN2通信_CM-CAN1_f107 can1 C
09-14
基于STM32F107VE 单片机的CAN1与CAN2的收发通讯基础例程。
STM32的CAN通信例程
12-02
STM32的CAN通信例程，很经典，大家看一下，使用C语言开发的，很好的学习资料，可以作为学习STM32和C语言的良好途径。
FMI接口标准简介
01-27
随着科学技术的发展，面对复杂系统设计和分析的手段逐渐丰富和完善，其中仿真技术越来越受到重视，在西方发达国家已在多个工业领域（航空、航天、汽车、船舶、核…）得到了成熟而广泛的应用。仿真技术的成熟应用为复杂系统设计提供了贯穿V流程全生命周期的分析手段，由于其分析方便、快捷，并可作为实物试验有效的补充手段，在仿真可信度较高的情况下可有效降低实物试验次数，进而节约成本，提高效率。但仿真技术发展至今，在取得工程应用认可的同时，也发现了一些不足和亟待改善的地方，例如如下图所示。图1仿真工具碎片化当前仿真工作开展过程中发现的问题和亟待完善的需求：◆
FMI-TOOLBOX用户手册
04-28
FMI Toolbox for Matlab/Simulink的安装和使用说明，详细讲解了如何使用该工具箱使Matlab生成fmu模型。
FMU/FMI
02-24
FMU/FMI是用于机电一体化设计的最新标准与接口，对于正向设计而言，它会对于复杂的系统设计带来很大的便利，虽然它最初来源于汽车这样的复杂设计，但同样可以被其它领域所采用。在汽车工业、航空、机电装备等领域都会存在着不同的应用、建模系统，用于解决不同的问题，为了仿真整个系统，往往需要在不同的仿真程序之间进行交互，而且系统的集成必须将来自不同供应商的仿真环境协同工作才能完整的调试，这产生了模型交互的需求，但却没有标准化的接口，因此为了解决这个问题，开发了FMU/FMI。工具独立的标准用于支持动态模型的交互以及联合仿真，用于解决汽车工业中模型互操作问题，最初是由欧盟资助的Modelisar项目，由戴
STM32F4 的CAN1 CAN2 双CAN收发例子
10-22
最简单清晰的例子，主架构如下： int main(void) { /* ST固件库中的启动文件已经执行了 SystemInit() 函数，该函数在 system_stm32f4xx.c 文件，主要功能是 配置CPU系统的时钟，内部Flash访问时序，配置FSMC用于外部SRAM等。 */ NVIC_Configuration(); CAN1_Configuration(); CAN2_Configuration(); while(1) { if(can1_rec_flag == 1) //如果CAN1接收到了一帧数据 { can1_rec_flag = 0; CAN1_WriteData(0x18412345); //以ID为 0x18412345向CAN上发送数据 } if(can2_rec_flag == 1) //如果CAN1接收到了一帧数据 { can2_rec_flag = 0; CAN2_WriteData(0x18412345); //以ID为 0x18412345向CAN上发送数据 } } }
CAN通信代码实现
qq_46946054的博客
06-19 3292
本文章对CAN的理论只做简单介绍，重点介绍怎么使用stm32f103单片机实现CAN通信。 文章实验使用stm32f103c8t6单片机，TJA1042T/3 CAN收发器，广成CAN分析仪，GCANTOOLS上位机软件（CAN分析仪官网下载）实现CAN报文的发送和接受。
STM32F4_CAN详解
light_2025的博客
06-21 2988
倘若两个节点同时竞争CAN总线的占有权，当它们发送报文时，若首先出现隐性电平，隐性电平和显性电平同时存在时，会显示为显性电平，隐性电平就会失去对总线的占有权，进入接收状态（因为CAN协议中只能一个结点发送数据，只要有一个节点在发送数据，那么其他的节点只能够在接收数据，就像是IIC的。1. 抗干扰能力强，当外界存在噪声干扰时，几乎会同时耦合到两条信号线上，但是接收端只关心两条信号线的差值（也就是说哪怕是有干扰，影响我两根线是同时干扰的，要么两根线的电平同时上升，要么两根线的电平同时下降，其差值是不变的。
CAN通信程序代码阅读总结
m0_56561130的博客
04-06 3871
文章目录1. eCAN模块GPIO初始化2. 初始化eCanb模块：InitEcanb 1. eCAN模块GPIO初始化 void InitECanbGpio(void) { EALLOW;//配置GPIO引脚工作在eCAN功能 GpioCtrlRegs.GPAPUD.bit.GPIO16 = 1; // Disable pull-up for GPIO16 (CANTXB) GpioCtrlRegs.GPAPUD.bit.GPIO17 = 0; // Enable pull-up
CAN总线详解及STM32的CAN通信编程指南
weixin_45812987的博客
07-10 6819
低速的CAN是属于开环总线，高速的CAN是属于闭环总线。CAN是一种通信的方式，就是用来传递数据的，是属于串行通信的一种，是异步的半双工通讯，根据通信速率的不同可以分为高速CAN和低速CAN，主要的区别是在于对总线电平和数据传输速率（波特率）的定义，分别遵循ISO的不同标准。CAN的总线是使用差分信号，其物理媒介是一对双绞线，这样差分信号的优点可以实现对干扰信号的抵消，总线上是CAN_High、CAN_Low.通过电位差来判断总线的电平，当然在这个地方高速CAN和低速CAN是不一样的。
STM32F4xx标准例程.rar
07-15
一共包含59个stm32f4单片机标准例程，所有例程均在 STM32F407开发板上测试通过。方便需要的直接下载使用，不用去其他地方找了。
基于STM32F4移植FreeRTOS实现CAN1 CAN2 双向通信例程
12-05
本例程基于STM32F407实现了FreeRTOS的移植，实现了CAN1、 CAN2的双向通信以及IAP的在线升级，但是程序中并不包含IAP过程，仅仅是APP部分，所以有需要的朋友在编译的时候需要对环境做一些设置，否则跑不起来，IAP 的程序会另外上传
STM32F103标准例程-库函数版本.rar
12-28
基于STM32F103标准库函数的基础例程，以keil为开发平台，主要以F103ZE开发板为例，适合基础学习。
stm32f407标准例程-库函数版本.zip
11-03
stm32f407标准例程-库函数版本.zip
STM32 HAL库F103系列之DAC实验（二）
2302_79878697的博客
04-24 576
转换的数字量及换算后的电压值。，配置定时器溢出频率并启动。滤波器，输出预设电压，输出正弦波，然后通过。
STM32，复位和时钟控制
m0_52883102的博客
04-24 335
外部时钟 HSE以后需要用到什么就这样直接拿去配就行了
学习STM32第十五天
dabuding666的博客
04-17 1711
学习STM32F4XX硬件SPI外设
成功解决STM32-No ST-LINK detected问题！
最新发布
qq_48361010的博客
04-28 230
按住复位按键（复位按键不要松开），进入下面地方查看。如果发现查找到下载器后，退出（点击右上角x号）。点击下载按钮，然后立刻松开复位按键，下载进去没有错误配置的代码。查看stm32复位按键的引脚，将复位引脚拉低（这个操作和按下复位按钮一样），然后根据有复位按键的步骤进行，最终问题解决！注意：下述方法多试几次，不一定一次就会成功！
STM32进入睡眠模式的方法
腹有诗词气自华
04-28 222
今天学习了如何控制STM32进入睡眠模式，进入睡眠模式的好处就是省电，今天学习的只是浅度睡眠，通过中断就能唤醒。比如单片机在那一放，也许好几天好几个月都不用一次，整天的在那空跑while循环，是不是有很大的资源浪费啊，这个时候就要用到这个睡眠模式了，没有收到串口数据的时候，你就可以睡觉，等到收到串口数据后再醒来执行一段代码，执行完后，接着睡觉，再等着下次收到数据（也就是产生串口中断的时候），这样就感觉合理的利用了单片机的功能，其实要想实现这样的功能，很简单只需要一句：__WFI();
基于是stm32 modbus通信keil例程
08-02
基于STM32的Modbus通信Keil例程是一种使用Keil开发环境的样例代码，它可以帮助开发人员在STM32微控制器上实现Modbus通信协议。Modbus是一种工业通信协议，常用于连接不同的设备，例如PLC和传感器等。该例程可以帮助实现Modbus主站和从机之间的通信。 该例程的主要功能包括： 1. 确定串口通信参数：通过设置波特率、数据位、校验位和停止位等参数，与Modbus从机建立稳定的串口连接。 2. 实现Modbus协议：通过编写相关代码，实现Modbus主站和从机之间的通信协议。这包括发送和接收Modbus请求和响应消息。 3. 读取和写入Modbus寄存器：通过例程，开发人员可以读取和写入Modbus从机上的寄存器。可以根据需要进行读取和写入操作，以实现数据的有效传输。 4. 错误处理：通过检测错误码和异常码，可以在通信过程中进行适当的错误处理。这有助于确保通信的稳定性和可靠性。 开发人员可以根据具体的应用需求进行修改和扩展该例程。例如，可以根据需要设置不同的Modbus功能码、寄存器地址和数据类型等。此外，还可以添加其他功能，如消息队列、数据解析和处理等。 通过使用基于STM32的Modbus通信Keil例程，开发人员可以更轻松地实现Modbus通信功能，提高开发效率，并为工业自动化应用提供可靠的通信解决方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值