(STM32)从零开始的RT-Thread之旅--SPI驱动ST7735(2)

已于 2023-05-10 09:28:08 修改
阅读量2.9k 收藏 20
点赞数 5
分类专栏： RT-Thread 文章标签： stm32 单片机 嵌入式硬件 rttread stm32H7
于 2022-11-18 17:10:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwe5959798/article/details/127924308
版权

本篇使用的驱动来自ST官方提供：

https://github.com/STMicroelectronics/stm32-st7735.git

需要的可以直接git clone下来移植，核心代码无关芯片型号，可移植性很不错！本篇用的ST7735库比官方新添加了一些内容，是开发板卖家提供的，地址：

WeActStudio

第一篇中我们打通了SPI，读取到了芯片ID，这一篇只要完善几个接口函数就可以直接使用官方的驱动库了。至于要完善哪几个接口，需要看一下官方驱动库需要哪些函数。

1.添加官方源代码

可以参照我上图的结构把几个源文件添加进去，其中font.h可以在WeAct那个github上找到。

添加完后记得把头文件路径也包含进去。

2.官方库使用方法

在添加完成后，新建lcd相关源文件，比如我的文件结构：

修改 st7735.h 中一处地方：

这个变量在st7735.c中被定义。 怎么使用库如下：

其中ST7735Ctx是库里面定义好的，我们直接使用即可。但是还需要两个变量：

st7735_pObj就是设备驱动实例，实际在屏幕上显示都是操作的它。关键是st7735_pIO这个变量，它负责提供底层接口。它里面包含的一些函数指针正是我们需要完成的。

在上一章的基础上，使用了两套SPI使用方式，如果定义 USE_RTT_SPI ，就是用RTT驱动框架提供的SPI接口函数，如果把它注释掉，则直接使用HAL库的SPI函数，具体实现我会附在后面。

实际我们使用的时候调用的函数是：

比如要填充整个屏幕为黑色：

附：

mspi.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2022-11-14     cx       the first version
 */
#include <rtthread.h>
#include <rtdevice.h>
#include <stm32h7xx.h>
#include <drv_spi.h>
#include <mspi.h>
#include "st7735_reg.h"
#include "st7735.h"

#define USE_RTT_SPI

SPI_HandleTypeDef *spi_handle;

#ifdef USE_RTT_SPI

static struct rt_spi_device *spi_lcd;

#define LCD_RD_HIGH rt_pin_write(SPI_RD_PIN_NUM, PIN_HIGH)
#define LCD_RD_LOW  rt_pin_write(SPI_RD_PIN_NUM, PIN_LOW)
#else
SPI_HandleTypeDef hspi4;
#define SPI_Drv (&hspi4)
#define LCD_CS_HIGH HAL_GPIO_WritePin(GPIOE,GPIO_PIN_11,GPIO_PIN_SET)
#define LCD_CS_LOW  HAL_GPIO_WritePin(GPIOE,GPIO_PIN_11,GPIO_PIN_RESET)

#define LCD_RD_HIGH HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_SET)
#define LCD_RD_LOW  HAL_GPIO_WritePin(GPIOE,GPIO_PIN_13,GPIO_PIN_RESET)
#endif

#ifdef USE_RTT_SPI
int32_t mspi_send_reg(uint8_t reg,uint8_t *data,uint32_t len)
{
    struct rt_spi_message msg;
    uint32_t remsg = RT_NULL;
    msg.send_buf = &reg;
    msg.recv_buf = RT_NULL;
    msg.length = 1;
    msg.cs_take = 1;
    msg.cs_release = 0;
    msg.next = RT_NULL;
    LCD_RD_LOW;
    remsg = (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    LCD_RD_HIGH;
    if(len > 0)
    {
        msg.send_buf = data;
        msg.recv_buf = RT_NULL;
        msg.length = len;
        msg.cs_take = 0;
        msg.cs_release = 1;
        msg.next = RT_NULL;
        remsg += (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    }
    if(remsg!=RT_NULL)
        return -1;
    else
        return 0;
}
int32_t mspi_read_reg(uint8_t reg,uint8_t *data)
{
    struct rt_spi_message msg;
    uint32_t remsg = RT_NULL;
    uint8_t reg1 = reg;
    msg.send_buf = &reg1;
    msg.recv_buf = RT_NULL;
    msg.length = 1;
    msg.cs_take = 1;
    msg.cs_release = 0;
    msg.next = RT_NULL;
    LCD_RD_LOW;
    remsg = (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    LCD_RD_HIGH;
    if(remsg == 0)
    {
        msg.send_buf = RT_NULL;
        msg.recv_buf = data;
        msg.length = 1;
        msg.cs_take = 0;
        msg.cs_release = 1;
        msg.next = RT_NULL;
        remsg += (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
    }
    if(remsg!=RT_NULL)
        return -1;
    else
        return 0;
}
int32_t mspi_send_data(uint8_t *data,uint32_t len)
{
    struct rt_spi_message msg;
    msg.send_buf = data;
    msg.recv_buf = RT_NULL;
    msg.length = len;
    msg.cs_take = 1;
    msg.cs_release = 1;
    msg.next = RT_NULL;
    return (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
}
int32_t mspi_read_data(uint8_t *data,uint32_t len)
{
    struct rt_spi_message msg;
    msg.send_buf = RT_NULL;
    msg.recv_buf = data;
    msg.length = len;
    msg.cs_take = 1;
    msg.cs_release = 1;
    msg.next = RT_NULL;
    return (uint32_t)rt_spi_transfer_message(spi_lcd,&msg);
}

#else
int32_t mspi_send_reg(uint8_t reg,uint8_t *data,uint32_t len)
{
    int32_t result;
    LCD_CS_LOW;
    LCD_RD_LOW;
    result = HAL_SPI_Transmit(SPI_Drv,&reg,1,100);
    LCD_RD_HIGH;
    if(len > 0)
        result += HAL_SPI_Transmit(SPI_Drv,data,len,500);
    LCD_CS_HIGH;
    if(result>0){
        result = -1;}
    else{
        result = 0;}
    return result;
}

int32_t mspi_read_reg(uint8_t reg,uint8_t *data)
{
    int32_t result;
    LCD_CS_LOW;
    LCD_RD_LOW;

    result = HAL_SPI_Transmit(SPI_Drv,&reg,1,100);
    LCD_RD_HIGH;
    result += HAL_SPI_Receive(SPI_Drv,data,1,500);
    LCD_CS_HIGH;
    if(result>0){
        result = -1;}
    else{
        result = 0;}
    return result;
}

int32_t mspi_send_data(uint8_t *data,uint32_t len)
{
    int32_t result;
    LCD_CS_LOW;
    //LCD_RD_HIGH;
    result =HAL_SPI_Transmit(SPI_Drv,data,len,100);
    LCD_CS_HIGH;
    if(result>0){
        result = -1;}
    else{
        result = 0;}
    return result;
}

int32_t mspi_read_data(uint8_t *data,uint32_t len)
{
    int32_t result;
    LCD_CS_LOW;
    //LCD_RD_HIGH;
    result = HAL_SPI_Receive(SPI_Drv,data,len,500);
    LCD_CS_HIGH;
    if(result>0){
        result = -1;}
    else{
        result = 0;}
    return result;
}
#endif
int32_t mspi_get_tick(void)
{
    return HAL_GetTick();
}
void mspi_rw_gpio_init(void)
{
#ifdef USE_RTT_SPI
    rt_pin_mode(SPI_RD_PIN_NUM, PIN_MODE_OUTPUT);
    rt_pin_write(SPI_RD_PIN_NUM, PIN_HIGH);
#else
    GPIO_InitTypeDef GPIO_InitStruct = {0};
    __HAL_RCC_GPIOE_CLK_ENABLE();
    HAL_GPIO_WritePin(GPIOE, GPIO_PIN_11|GPIO_PIN_13, GPIO_PIN_SET);
    GPIO_InitStruct.Pin = GPIO_PIN_11|GPIO_PIN_13;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
#endif
}
void mspi_init(void)
{
    mspi_rw_gpio_init();
#ifdef USE_RTT_SPI
    struct rt_spi_configuration cfg;
    rt_hw_spi_device_attach("spi4", "spi40", GPIOE, GPIO_PIN_11);
    spi_lcd = (struct rt_spi_device *)rt_device_find("spi40");
    if(!spi_lcd)
    {
        rt_kprintf("spi40 can't find\n");
    }
    else
    {
        spi_lcd->bus->owner = spi_lcd;
        cfg.data_width = 8;
        cfg.mode = RT_SPI_MASTER | RT_SPI_3WIRE | RT_SPI_MODE_0 | RT_SPI_MSB;
        cfg.max_hz = 12.5 * 1000 * 1000;
        rt_spi_configure(spi_lcd, &cfg);
    }
    //也可以初始化使用框架提供的函数，发送接收使用HAL库函数，操作对象就是下面的 spi_handle
//    struct stm32_spi *spi_drv =  rt_container_of(spi_lcd->bus, struct stm32_spi, spi_bus);
//    spi_handle = &spi_drv->handle;
#else
    hspi4.Instance = SPI4;
    hspi4.Init.Mode = SPI_MODE_MASTER;
    hspi4.Init.Direction = SPI_DIRECTION_1LINE;
    hspi4.Init.DataSize = SPI_DATASIZE_8BIT;
    hspi4.Init.CLKPolarity = SPI_POLARITY_LOW;
    hspi4.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi4.Init.NSS = SPI_NSS_SOFT;
    hspi4.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
    hspi4.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi4.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi4.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi4.Init.CRCPolynomial = 0x0;
    hspi4.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
    hspi4.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
    hspi4.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
    hspi4.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    hspi4.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
    hspi4.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
    hspi4.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
    hspi4.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
    hspi4.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
    hspi4.Init.IOSwap = SPI_IO_SWAP_DISABLE;
    if (HAL_SPI_Init(&hspi4) != HAL_OK)
    {
      rt_kprintf("ERROR\n");
    }
#endif
}

mlcd.c

/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2022-11-15     cx       the first version
 */
#include <stdio.h>
#include <rtthread.h>
#include <rtdevice.h>
#define DBG_TAG "mlcd"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>
#include "mpwm.h"
#include "mspi.h"
#include "st7735_reg.h"
#include "st7735.h"
#include "mlcd.h"
#include "font.h"
#include <stm32h7xx.h>

int32_t mlcd_st7735_init(void);

ST7735_IO_t st7735_pIO = {
    mlcd_st7735_init,
    NULL,
    0,
    mspi_send_reg,
    mspi_read_reg,
    mspi_send_data,
    mspi_read_data,
    mspi_get_tick
};

ST7735_Object_t st7735_pObj;

int32_t mlcd_st7735_init(void)
{
    int32_t result = ST7735_OK;
    mpwm_init();
    mspi_init();
    return result;
}

int mlcd_init(void)
{
    uint32_t st7735_id;
    uint8_t text[50];
    #ifdef TFT96
    ST7735Ctx.Orientation = ST7735_ORIENTATION_LANDSCAPE_ROT180;
    ST7735Ctx.Panel = HannStar_Panel;
    ST7735Ctx.Type = ST7735_0_9_inch_screen;
    #elif TFT18
    ST7735Ctx.Orientation = ST7735_ORIENTATION_PORTRAIT;
    ST7735Ctx.Panel = BOE_Panel;
    ST7735Ctx.Type = ST7735_1_8_inch_screen;
    #else
    LOG_E("Unknown Screen");
    #endif
    ST7735_RegisterBusIO(&st7735_pObj,&st7735_pIO);
    ST7735_LCD_Driver.Init(&st7735_pObj,ST7735_FORMAT_RBG565,&ST7735Ctx);
    ST7735_LCD_Driver.ReadID(&st7735_pObj,&st7735_id);
    rt_kprintf("LCD ID:%08X\n",st7735_id);

    ST7735_LCD_Driver.FillRect(&st7735_pObj, 0, 0, ST7735Ctx.Width,ST7735Ctx.Height, BLACK);

    sprintf((char *)&text, "Something V1.0");
    LCD_ShowString(4, 4, ST7735Ctx.Width, 16, 16, text);

    return 0;
}

uint16_t POINT_COLOR=0xFFFF;    //画笔颜色
uint16_t BACK_COLOR=BLACK;  //背景色
//在指定位置显示一个字符
//x,y:起始坐标
//num:要显示的字符:" "--->"~"
//size:字体大小 12/16
//mode:叠加方式(1)还是非叠加方式(0)

void LCD_ShowChar(uint16_t x,uint16_t y,uint8_t num,uint8_t size,uint8_t mode)
{
  uint8_t temp,t1,t;
    uint16_t y0=y;
    uint16_t x0=x;
    uint16_t colortemp=POINT_COLOR;
  uint32_t h,w;

    uint16_t write[size][size==12?6:8];
    uint16_t count;

  ST7735_GetXSize(&st7735_pObj,&w);
    ST7735_GetYSize(&st7735_pObj,&h);

    //设置窗口
    num=num-' ';//得到偏移后的值
    count = 0;

    if(!mode) //非叠加方式
    {
        for(t=0;t<size;t++)
        {
            if(size==12)temp=asc2_1206[num][t];  //调用1206字体
            else temp=asc2_1608[num][t];         //调用1608字体

            for(t1=0;t1<8;t1++)
            {
                if(temp&0x80)
                    POINT_COLOR=(colortemp&0xFF)<<8|colortemp>>8;
                else
                    POINT_COLOR=(BACK_COLOR&0xFF)<<8|BACK_COLOR>>8;

                write[count][t/2]=POINT_COLOR;
                count ++;
                if(count >= size) count =0;

                temp<<=1;
                y++;
                if(y>=h){POINT_COLOR=colortemp;return;}//超区域了
                if((y-y0)==size)
                {
                    y=y0;
                    x++;
                    if(x>=w){POINT_COLOR=colortemp;return;}//超区域了
                    break;
                }
            }
        }
    }
    else//叠加方式
    {
        for(t=0;t<size;t++)
        {
            if(size==12)temp=asc2_1206[num][t];  //调用1206字体
            else temp=asc2_1608[num][t];         //调用1608字体
            for(t1=0;t1<8;t1++)
            {
                if(temp&0x80)
                    write[count][t/2]=(POINT_COLOR&0xFF)<<8|POINT_COLOR>>8;
                count ++;
                if(count >= size) count =0;

                temp<<=1;
                y++;
                if(y>=h){POINT_COLOR=colortemp;return;}//超区域了
                if((y-y0)==size)
                {
                    y=y0;
                    x++;
                    if(x>=w){POINT_COLOR=colortemp;return;}//超区域了
                    break;
                }
            }
        }
    }
    ST7735_FillRGBRect(&st7735_pObj,x0,y0,(uint8_t *)&write,size==12?6:8,size);
    POINT_COLOR=colortemp;
}

//显示字符串
//x,y:起点坐标
//width,height:区域大小
//size:字体大小
//*p:字符串起始地址
void LCD_ShowString(uint16_t x,uint16_t y,uint16_t width,uint16_t height,uint8_t size,uint8_t *p)
{
    uint8_t x0=x;
    width+=x;
    height+=y;
    while((*p<='~')&&(*p>=' '))//判断是不是非法字符!
    {
        if(x>=width){x=x0;y+=size;}
        if(y>=height)break;//退出
        LCD_ShowChar(x,y,*p,size,0);
        x+=size/2;
        p++;
    }
}

STM32F103+RT-Thread从零开始（一）——点亮LED
weixin_42976659的博客
03-29 4103
STM32系列MCU STM32系列芯片包括F0/F1/F2/F3/F4/F7/L0/L1/L4/H7等系列芯片芯片。不同系列的芯片适用于不同的应用场景。 F0/L0基于ARM Cortex-M0，F1/F2/L1系列基于ARM Cortex-M3，F3/F4/L4系列基于ARM Cortex-M4，F7/H7基于ARM Cortex-M7。L系列表示超低功耗，H表示超高性能（对应就是高功耗了），...
STM32开发 --- 1.8寸显示屏ST7735_输出英文、汉字、图片
zhouml_msn的博客
09-05 1万+
之前根据厂商代码，重写了一次输出函数，使输出更方便，但毕竟是摸拟SPI的，总感觉有点慢。 再次重写，重点：SPI通信 + 图像输出函数。 ST7735操作重点 DC/RS引脚置低电平，SPI发送过去的数据被用作指令值(寄存器地址)；引脚置高电平，SPI发送过去的值被当作是数据值 操作时，先指令值，后数据 其它的就不多说了，直接代码参考吧 ...
ST7735S彩屏 SPI驱动代码( msp430)
11-21
本代码采用SPI驱动，为自己做项目时整理，用该屏做简单的UI界面，LCD驱动部分有详细讲解，希望对有用的人能有些帮助。 支持中英文、位图显示(电量，信号灯简单图形)，字库均自己制作；支持横屏和竖屏。该代码仅供学习参考。
rtthread SPI驱动解读
最新发布
qq_42733689的博客
09-16 348
参考资料[1][2]
ST7735S_initial_code.c TFT屏驱动程序
03-29
ST7735S_initial_code.cTFT屏驱动程序 ST7735S_initial_code.cTFT屏驱动程序
在linux上使用spi-lcd屏 ST7735
QQ135102692的博客
05-27 4766
一、ST7735介绍 ST7735是一款spi驱动的lcd屏，通过spi发送用于操作lcd的寄存器指令和显示数据​​​​​​​ 二、ST7735操作模式 当DC引脚为低，命令模式，目的是设置芯片显示参数等 当DC引脚为高，数据模式，发送的数据应该为图像rgb数据，保存在display ram并显示 BLK是控制LCD背光（不开背光，无法显示） 三、ST7735 ...
基于micropython的st7735s驱动
supermodule的博客
01-21 1869
基于micropython esp32开发的st7735s驱动代码
RT-Thread 设备驱动SPI浅析及使用
weixin_30664051的博客
05-31 1248
OS版本：RT-Thread 4.0.0 测试BSP：STM32F407 SPI简介 SPI总线框架其实和I2C差不多，可以说都是总线设备+从设备，但SPI设备的通信时序配置并不固定，也就是说控制特定设备的总线需要单独配置； SPI的特性是工作方式众多，有标准SPI和QSPI QSPI:QSPI 是 Queued SPI 的简写，是 Motorola 公司推出的 SPI 接口的扩展，比...
STM32L496接入微软 Azure 物联网平台【RT-Thread工程，支持STM32L4系列单片机】.zip
05-16
这使得开发者可以快速构建复杂的应用系统，而无需从零开始编写基础系统服务。 本项目是将STM32L496与微软Azure物联网平台连接的实例，展示了如何在RT-Thread操作系统上实现这一目标。Azure IoT是一个全面的云服务...
RT-Thread_stm32f105工程模板
09-24
此外，模板已包含内核相关的所有必要文件，开发者可以直接在STM32F105平台上快速构建自己的应用程序，无需从零开始设置整个环境。 使用RT-Thread_stm32f105工程模板的开发者可以受益于RTThread提供的以下特性： 1. ...
stm32f407正点原子开发板屏幕驱动程序
11-21
STM32F407是一款基于ARM Cortex-M4内核的微控制器，广泛应用于...这个驱动程序的即用性意味着开发者只需要按照一定的说明或教程，就可以快速在STM32F407开发板上实现TFT-LCD的显示功能，无需从零开始编写所有代码。
2.4寸tft-ST7735驱动代码
12-21
网上找不到能显示中文的ST7735驱动，所以自己就写了一个，并且封装好了
STM32F103C8T6+1.44寸ST7735TFT LCD彩屏驱动程序
10-09
资源是STM32F103C8T6的1.44寸ST7735芯片SPI驱动的TFT液晶屏驱动程序完整KEIL工程，需要的朋友可以下载，改个IO口就能够使用，非常方便！说明文档连接为：https://blog.csdn.net/pang9998/article/details/85837421
51驱动ST7735S
04-15
51单片机驱动ST7735S51的代码，个人向_ST7735S_CTC177 4-wire
ST7735(GYTF018LB35B0M)，C语言，驱动
05-14
1.8寸TFT显示屏，ST7735的驱动。GYTF018LB35模块使用，89C52、8位并口驱动。如果是使用的是SPI通信或者是STM32使用，都只需要修改两个函数（LCD_Write、LCD_Write_Data16）的内部，即可。
如何基于RT-Thread制作开源飞控StarryPilot？
FILLMOREad的博客
07-18 1410
  背景描述 近年来无人机应用市场日趋火热，无人机开始被应用在多个领域之中，比如航拍，植保，运输，安防等。随着应用场景的增加，对于无人机的大脑一飞控，的性能和功能要求也变得越来越高。国内具有一大批优质的无人机企业，如DJI，零度，亿航，极飞等。可是这些企业的飞控系统并不开源，而开源飞控市场却基本被国外所垄断，比如APM, PX4, Autoquad等，国内目前还没有一款开源飞控可以与之抗衡，在...
RT-thread使用SPI驱动WS2812B多图小白教程
godmial的博客
10-12 888
关于ws2812b详细的相关信息可以参考代码会放在最下方，话不多说直接开始。
STM32进阶：使用STM32驱动ST7735S（内附核心源码）
热门推荐
混子还在路上
11-28 1万+
感觉很久很久没有来博客更新了，历经千难万阻，终于做出来了TFT显示屏的SPI驱动，这里分享以下核心源码，接下来一段时间开始准备考科一了，后面有时间了再来更新，有三种模式下的驱动。实验环境：正点原子 STM32F103ZET6 小型系统板 实验工具：STM32F103ZET6 芯片与 ST7735S芯片（1.44寸TFT显示屏） 数据交互：STM32 芯片通过 GPIO 输入输出引脚模拟软件SPI和TFT液晶显示屏进行通信、数据传输及命令背景光等控制。 实验成效：见STM32F103VET6用SPI驱动ST7
RT-Thread SPI设备驱动框架详解与STM32F4示例
内容包括如何通过menuconfig命令行工具修改工程的芯片型号，以及介绍了RT-Thread的SPI设备驱动框架，提供了SPI设备驱动的使用方法和一个基于STM32F4探索者开发板的SPI设备驱动示例，以OLED显示屏为例进行说明。...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值