tslib中对linux fb操作接口的封装

最新推荐文章于 2024-04-15 13:53:23 发布
最新推荐文章于 2024-04-15 13:53:23 发布
阅读量380 收藏 2
点赞数
分类专栏： linuxfb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuu19/article/details/103092510
版权

嵌入式调试显示屏，可能用过tslib，其中有些代码拿出来就是对linux fb不错的封装。

例如如下程序，就是tslib中的部分代码，大家可以直接使用，或者再加工修改：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <fcntl.h>

#include <linux/vt.h>
#include <linux/kd.h>
#include <linux/fb.h>


/*****************************************************************************
 *
 * Macro definition
 *
 *****************************************************************************/
// 
#define VTNAME_LEN                      (128)


/*****************************************************************************
 *
 * Structure/Class Definition
 *
 *****************************************************************************/
union multiptr {
    uint8_t     *p8;
    uint16_t    *p16;
    uint32_t    *p32;
};


/*****************************************************************************
 *
 * Data definition
 *
 *****************************************************************************/
static int32_t con_fd = -1;
static int32_t last_vt = -1;

static struct fb_fix_screeninfo fix;
static struct fb_var_screeninfo var;

static unsigned char *fbuffer = NULL;
static unsigned char **line_addr = NULL;

static int32_t fb_fd;
static int32_t bytes_per_pixel;
static uint32_t transp_mask;

uint32_t xres, yres;
uint32_t xres_orig, yres_orig;
int8_t rotation;
// 0 ... no rotation; 0 degree (default)
// 1 ... clockwise orientation; 90 degrees
// 2 ... upside down orientation; 180 degrees
// 3 ... counterclockwise orientation; 270 degrees

static const char *defaultfbdevice = "/dev/fb0";
//static char *defaultconsoledevice = "/dev/tty";
static const char *fbdevice;
static const char *consoledevice;


/*****************************************************************************
 *
 * Function Entity
 *
 *****************************************************************************/
int FbOpen(const char *fb_dev, const char * console_dev, uint32_t *max_width, uint32_t *max_height)
{
    struct vt_stat vts;
    char vtname[VTNAME_LEN];
    int32_t fd, nr;
    uint32_t y, addr;

    //
    if (NULL == fb_dev)
    {
        fbdevice = defaultfbdevice;
    }
    else
    {
        fbdevice = fb_dev;
    }
    

    //
    if (NULL == console_dev)
    {
        consoledevice = "none";
    }
    else
    {
        consoledevice = console_dev;
    }
    

    if (strcmp(consoledevice, "none") != 0)
    {
        if (strlen(consoledevice) >= VTNAME_LEN)
        {
            return -1;
        }

        sprintf(vtname, "%s%d", consoledevice, 1);
        fd = open(vtname, O_WRONLY);
        if (fd < 0)
        {
            perror("open consoledevice");
            return -1;
        }

        if (ioctl(fd, VT_OPENQRY, &nr) < 0)
        {
            close(fd);
            perror("ioctl VT_OPENQRY");
            return -1;
        }
        close(fd);

        sprintf(vtname, "%s%d", consoledevice, nr);

        con_fd = open(vtname, O_RDWR | O_NDELAY);
        if (con_fd < 0)
        {
            perror("open tty");
            return -1;
        }

        if (ioctl(con_fd, VT_GETSTATE, &vts) == 0)
            last_vt = vts.v_active;

        if (ioctl(con_fd, VT_ACTIVATE, nr) < 0)
        {
            perror("VT_ACTIVATE");
            close(con_fd);
            return -1;
        }

#ifndef TSLIB_NO_VT_WAITACTIVE
        if (ioctl(con_fd, VT_WAITACTIVE, nr) < 0)
        {
            perror("VT_WAITACTIVE");
            close(con_fd);
            return -1;
        }
#endif

        if (ioctl(con_fd, KDSETMODE, KD_GRAPHICS) < 0)
        {
            perror("KDSETMODE");
            close(con_fd);
            return -1;
        }
    }

    fb_fd = open(fbdevice, O_RDWR);
    if (fb_fd == -1)
    {
        perror("open fbdevice");
        return -1;
    }

    if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &fix) < 0)
    {
        perror("ioctl FBIOGET_FSCREENINFO");
        close(fb_fd);
        return -1;
    }

    if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &var) < 0)
    {
        perror("ioctl FBIOGET_VSCREENINFO");
        close(fb_fd);
        return -1;
    }

    xres_orig = var.xres;
    yres_orig = var.yres;

    if (rotation & 1)
    {
        /* 1 or 3 */
        y = var.yres;
        yres = var.xres;
        xres = y;
    }
    else
    {
        /* 0 or 2 */
        xres = var.xres;
        yres = var.yres;
    }

    fbuffer = mmap(NULL,
                   fix.smem_len,
                   PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED,
                   fb_fd,
                   0);


    if (fbuffer == (unsigned char *)-1)
    {
        printf("%s - smem_len = %d, fb = %d\n\r", __func__, fix.smem_len, fb_fd);
        perror("mmap framebuffer");
        close(fb_fd);
        return -1;
    }
    memset(fbuffer, 0, fix.smem_len);

    bytes_per_pixel = (var.bits_per_pixel + 7) / 8;
    transp_mask = ((1 << var.transp.length) - 1) << var.transp.offset; // transp.length unlikely > 32
    line_addr = malloc(sizeof(*line_addr) * var.yres_virtual);
    addr = 0;
    for (y = 0; y < var.yres_virtual; y++, addr += fix.line_length)
    {
        line_addr[y] = fbuffer + addr;
    }


    if (max_width != NULL && max_height != NULL)
    {
        *max_width = xres;
        *max_height = yres;
    }


    return 0;
}


void FbClose(void)
{
    memset(fbuffer, 0, fix.smem_len);
    munmap(fbuffer, fix.smem_len);
    close(fb_fd);

    if (strcmp(consoledevice, "none") != 0)
    {
        if (ioctl(con_fd, KDSETMODE, KD_TEXT) < 0)
        {
            perror("KDSETMODE");
        }

        if (last_vt >= 0)
        {
            if (ioctl(con_fd, VT_ACTIVATE, last_vt))
            {
                perror("VT_ACTIVATE");
            }
        }

        close(con_fd);
    }

    free(line_addr);

    xres = 0;
    yres = 0;
    rotation = 0;

    fbuffer = NULL;
    line_addr = NULL;
}

static void __PixelLocate(int32_t x, int32_t y, union multiptr *loc)
{
    if (NULL == line_addr)
    {
        loc->p8 = NULL;
        return;
    }

    switch (rotation)
    {
    case 0:
    default:
        loc->p8 = line_addr[y] + x * bytes_per_pixel;
        break;
    case 1:
        loc->p8 = line_addr[x] + (yres - y - 1) * bytes_per_pixel;
        break;
    case 2:
        loc->p8 = line_addr[yres - y - 1] + (xres - x - 1) * bytes_per_pixel;
        break;
    case 3:
        loc->p8 = line_addr[xres - x - 1] + y * bytes_per_pixel;
        break;
    }
}



static inline void __SetPixel(union multiptr loc, uint32_t xormode, uint32_t color)
{
    if (NULL == loc.p8)
    {
        return;
    }


    switch (bytes_per_pixel)
    {
    case 1:
    default:
        if (xormode)
            *loc.p8 ^= color;
        else
            *loc.p8 = color;
        break;
    case 2:
        if (xormode)
            *loc.p16 ^= color;
        else
            *loc.p16 = color;
        break;
    case 3:
        if (xormode)
        {
            *loc.p8++ ^= (color >> 16) & 0xff;
            *loc.p8++ ^= (color >> 8) & 0xff;
            *loc.p8 ^= color & 0xff;
        }
        else
        {
            *loc.p8++ = (color >> 16) & 0xff;
            *loc.p8++ = (color >> 8) & 0xff;
            *loc.p8 = color & 0xff;
        }
        break;
    case 4:
        if (xormode)
            *loc.p32 ^= color;
        else
            *loc.p32 = color;
        break;
    }
}


// 绘制一个像素点
void FbDrawPixel(int32_t x, int32_t y, uint32_t color)
{
    uint32_t xormode;
    union multiptr loc;

    if ((x < 0) || ((uint32_t)x >= xres) || (y < 0) || ((uint32_t)y >= yres))
    {
        return;
    }

    xormode = 0;

    __PixelLocate(x, y, &loc);
    __SetPixel(loc, xormode, color);
}


// 绘制一条直线，任何2点之间的直线
void FbDrawBeeLine(int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, uint32_t color)
{
    int32_t tmp;
    int32_t distance_x = x_end - x_start;
    int32_t distance_y = y_end - y_start;

    if (abs(distance_x) < abs(distance_y))
    {
        if (y_start > y_end)
        {
            tmp = x_start;
            x_start = x_end;
            x_end = tmp;
            tmp = y_start;
            y_start = y_end;
            y_end = tmp;
            distance_x = -distance_x;
            distance_y = -distance_y;
        }
        x_start <<= 16;
        // distance_y is apriori > 0 
        distance_x = (distance_x << 16) / distance_y;
        while (y_start <= y_end)
        {
            FbDrawPixel(x_start >> 16, y_start, color);
            x_start += distance_x;
            y_start++;
        }
    }
    else
    {
        if (x_start > x_end)
        {
            tmp = x_start;
            x_start = x_end;
            x_end = tmp;
            tmp = y_start;
            y_start = y_end;
            y_end = tmp;
            distance_x = -distance_x;
            distance_y = -distance_y;
        }
        y_start <<= 16;
        distance_y = distance_x ? (distance_y << 16) / distance_x : 0;
        while (x_start <= x_end)
        {
            FbDrawPixel(x_start, y_start >> 16, color);
            y_start += distance_y;
            x_start ++;
        }
    }
}


// 绘制一个矩形框
void FbDrawRectLine(int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, uint32_t color)
{
    FbDrawBeeLine(x_start, y_start,     x_end,   y_start,     color);
    FbDrawBeeLine(x_end,   y_start + 1, x_end,   y_end - 1,   color);
    FbDrawBeeLine(x_end,   y_end,       x_start, y_end,       color);
    FbDrawBeeLine(x_start, y_end - 1,   x_start, y_start + 1, color);
}



void CoordinateChk(int32_t *x_start, int32_t *y_start, int32_t *x_end, int32_t *y_end)
{
    int32_t x_loc;
    int32_t y_loc;

    // Clipping and sanity checking 
    if (*x_start > *x_end)
    {
        x_loc = *x_start;
        *x_start = *x_end;
        *x_end = x_loc;
    }
    if (*y_start > *y_end)
    {
        y_loc = *y_start;
        *y_start = *y_end;
        *y_end = y_loc;
    }

    if (*x_start < 0)
    {
        *x_start = 0;
    }
    if ((uint32_t)(*x_start) >= xres)
    {
        *x_start = xres - 1;
    }

    if (*x_end < 0)
    {
        *x_end = 0;
    }
    if ((uint32_t)(*x_end) >= xres)
    {
        *x_end = xres - 1;
    }

    if (*y_start < 0)
    {
        *y_start = 0;
    }
    if ((uint32_t)(*y_start) >= yres)
    {
        *y_start = yres - 1;
    }

    if (*y_end < 0)
    {
        *y_end = 0;
    }
    if ((uint32_t)(*y_end) >= yres)
    {
        *y_end = yres - 1;
    }
}



// 绘制一个实心矩形
void FbFillRect(int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, uint32_t color)
{
    int32_t x_loc;
    int32_t y_loc;
    uint32_t xormode = 0;
    union multiptr loc;

    // Clipping and sanity checking 
    CoordinateChk(&x_start, &y_start, &x_end, &y_end);

    if ((x_start > x_end) || (y_start > y_end))
    {
        return;
    }


    // 
    for (y_loc = y_start; y_loc <= y_end; ++y_loc)
    {
        for (x_loc = x_start; x_loc <= x_end; ++x_loc)
        {
            __PixelLocate(x_loc, y_loc, &loc);
            __SetPixel(loc, xormode, color);
            //loc.p8 += bytes_per_pixel;
        }
    }
}



// 根据输入的图像，绘制一个矩形图案，图案为ARGB
void FbFillRectPicture(int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, uint32_t *pic_color)
{
    int32_t x_loc;
    int32_t y_loc;
    int32_t height;
    int32_t width;
    uint32_t xormode = 0;
    union multiptr loc;


    // Clipping and sanity checking 
    CoordinateChk(&x_start, &y_start, &x_end, &y_end);

    if ((x_start > x_end) || (y_start > y_end))
    {
        return;
    }


    //
    height = y_end - y_start + 1;
    width  = x_end - x_start + 1;


    // 
    for (y_loc = y_start; y_loc <= y_end; ++y_loc)
    {
        for (x_loc = x_start; x_loc <= x_end; ++x_loc)
        {
            __PixelLocate(x_loc, y_loc, &loc);
            __SetPixel(loc, xormode, pic_color[x_loc - x_start]);
        }

        pic_color += width;
    }
}

// 绘制一个单色矩形图案，将输入的8bit像素值，拷贝到RGB
void FbFillRectPictureByYUV400(int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, uint8_t *pic_color)
{
    int32_t x_loc;
    int32_t y_loc;
    int32_t height;
    int32_t width;
    uint32_t xormode = 0;
    uint32_t color;
    union multiptr loc;


    // Clipping and sanity checking 
    CoordinateChk(&x_start, &y_start, &x_end, &y_end);

    if ((x_start > x_end) || (y_start > y_end))
    {
        return;
    }


    //
    height = y_end - y_start + 1;
    width  = x_end - x_start + 1;

    //printf("%s - x_start = %d, x_end = %d, width = %d\n\r", __func__, x_start, x_end, width);
    //printf("%s - y_start = %d, y_end = %d, width = %d\n\r", __func__, y_start, y_end, height);


    // 
    for (y_loc = y_start; y_loc <= y_end; ++y_loc)
    {
        for (x_loc = x_start; x_loc <= x_end; ++x_loc)
        {
            color = 0xff000000 | (pic_color[x_loc - x_start] << 16) | (pic_color[x_loc - x_start] << 8) | (pic_color[x_loc - x_start]);
            __PixelLocate(x_loc, y_loc, &loc);
            __SetPixel(loc, xormode, color);
        }

        pic_color += width;
    }
}
wuu19
关注
专栏目录
Linux小项目-数码相册设计
05-01 2511
这是基于Linux系统开发板设计一个小项目-数码相册，在LCD屏上可以显示完成常见的图片显示，翻页、旋转、缩放等功能。
ARM9嵌入式Linux开发-嵌入式GUI开发
ce123的技术博客
08-09 1311
GUI的一般架构 图形用户界面GUI（Graphics User Interface）是迄今为止计算机系统中最为成熟的人机交互技术。一个好的图形用户界面的设计不仅要考虑到具体硬件环境的限制，而且还要考虑到用户的喜好等。 由于图形用户界面的引入主要是从用户角度出发的，因此用户自身的主观感受对图形用户界面的评价占了很大比重，比如，易用性、直观性、友好性，等等。另外，从纯技术的角度看，仍然也会有一些标准需要考虑，比如，跨平台性、对硬件的要求等。在嵌入式系统开发和应用中，我们所考虑的问题主要集中在图形用户界面对
linux qt qpa linuxfb,Qt 5.4带有Tslib的Linux触摸屏输入在Raspberry Pi上无法使用LinuxFB QPA平台插件...
weixin_33331063的博客
05-12 348
我为我的Raspberry Pi买了一台Tontec 2.4英寸触摸屏(http://elinux.org/MZTX-PI-EXT) . 触摸屏控制器需要elinux帖子中描述的"tsc2007.ko"和"tsp_raspi.ko"内核模块 . tsc2007.ko模块位于Raspbian内核树中，但可以在此处找到tsp_raspi.ko：https://github.com/osandov/r...
tslib Linux命令测试,迅为IMX6ULL开发板Linux下电容触摸屏实验-Tslib移植和使用
weixin_36200896的博客
04-28 424
54.5 Tslib移植和使用ft5426 触摸驱动添加成功后，发现触摸可能不太准确，这时可以使用一个第三方开源库 tslib 来调试触摸屏。下面来看一下 tslib 源码如何移植。54.5.1获取 tslib源码tslib 源码可以从官方地址获取：https://github.com/libts/tslib，打开网址可以看到最新的版本是 1.21，可以从官网获取，也可以从网盘资料中获...
linux学习：输入设备+tslib库控制触控屏应用接口
最新发布
weixin_59669309的博客
04-15 897
连接操作系统的输入设备，可不止一种，也许是一个标准 PS/2 键盘，也许是一个 USB 鼠标，或者是一块触摸屏，甚至是一个游戏机摇杆，Linux 在处理这些纷繁各异的输入设备的时候，采用的办法还是找中间层来屏蔽各种细节在 Linux 的内核中，对输入设备的使用，实际上运用了 3 大块来管理，他们分别是所 谓的输入设备驱动层、输入子系统核心层，以及事件触发层。
触摸板库tslib的编译和配置
weixin_33758863的博客
10-25 161
作为基本输入设备，触摸板几乎是交互式嵌入式系统的标配。当我们知道了可以通过设备节点读取触摸板数据后，我们需要进一步优化这些直接获取的原生数据，比如去抖...
使用 tslib 库
学习记录
01-18 1717
使用 tslib 库
基于Linux操作系统的网络应用软件开发.pdf
09-30
而“LinuxFB”可能是指通过Linux FrameBuffer接口与显示设备交互。 综上所述，基于Linux操作系统的网络应用软件开发是一个复杂的过程，需要开发者具备Linux系统知识、网络编程技能、Qt框架使用经验，以及ARM平台的...
qt4源码编译linux,嵌入式Linux开发环境搭建-（6）交叉编译QT4.8.7源码生成qmake工具...
weixin_35960434的博客
05-08 710
交叉编译QT4.8.7源码生成qmake工具TQ-i.MX6UL使用的QT版本是QT4.8.7，板卡出厂前附带的开发资料中，天嵌官方没有为开发者编译生成qmake工具。因此，为了后续进行的QT开发，我们需要自己手动编译QT源码，生成qmake。编译前准备：确保交叉编译器版本是arm-linux-gnueabihf-gcc 5.3.1 20160412 (Linaro GCC 5.3-2016.05...
linux中安装Qt 4.8.5
scottly的专栏
04-18 7450
为了后面能够移植到arm开发板上
linux fb-test-帧缓冲 两个例子（完整源代码）
06-18
linux fb-test-帧缓冲 两个例子（完整源代码），在Ubuntu上实验通过。
tslib Linux命令测试,tslib 的编译和触摸屏的测试
weixin_42138376的博客
04-28 447
在编写完触摸屏的驱动程序以后，就可以使用通过编译tslib确定自己的驱动程序是否可以，也可以通过tslib调试自己对坐标的处理。一、 编译cd /root/imx27/tslib-1.3export CC=arm-linux-gcc./autogen.shecho “ac_cv_func_malloc_0_nonnull=yes”>arm-linux.cache./configure --h...
海思3531D移植tslib 解决同时使用鼠标和触摸屏的功能
weixin_41134703的博客
06-22 1016
交叉编译网上材料很多了 tslib/etc/ts.config中的内容（注释去掉了） module_raw input module pthres pmin=1 module variance delta=30 module dejitter delta=100 module linear 在板子 /etc/profile 下添加 #add tslib export T_ROOT=/usr/tslib export TSLIB_TSEVENTTYPE=INPUT export TSLIB_.
linuxfb简单说明
学习记录
08-27 9567
linuxfb简单说明
Linux驱动：基于framebuffer(fb)的驱动分析
weixin_44498318的博客
05-17 3295
基于framebuffer的驱动分析 framebuffer帧缓冲（简称fb）是linux内核中用代码虚拟出的一个设备，是一个platform类型设备，设备文件位于/dev/fb* 在嵌入式系统中一般没有专门的显存，而仅仅是从RAM(SDRAM)空间中分配一段显示缓冲区 framebuffer的作用是：向应用层提供一个统一标准接口的显示设备。不论最终输出是通过hdmi还是lcd控制器，可以认为所有的GUI都...
Linux上实现锁定和解锁键盘
zhangdaolong
07-13 440
这个程序通过打开键盘设备文件`/dev/tty`，使用`ioctl`函数将键盘模式设置为图形模式（`KD_GRAPHICS`）来锁定键盘。然后，可以编写适当的用户鉴别逻辑，例如要求输入密码进行解锁。最后，使用`ioctl`函数将键盘模式设置回文本模式（`KD_TEXT`）来解锁键盘。
VT_ACTIVATE failed: Input/output error
本博客仅供免费阅读，不提供咨询服务。请勿私信。
12-15 1770
[  2081.231] (**) Option "Device" "/dev/input/event5" [  2081.231] (**) Option "_source" "server/udev" [  2081.232] (II) event5  - SZH USB Keyboard System Control: is tagged by udev as: Keyboard [  2...
基于qemu-riscv从0开始构建嵌入式linux系统ch23. linux FB应用——Qt库移植
Quard_D的博客
08-21 1754
基于qemu-riscv从0开始构建嵌入式linux系统ch23. linux FB应用——Qt库移植 {TODO:文档施工中，笔者将很快编纂完成} 本教程的github仓库：https://github.com/QQxiaoming/quard_star_tutorialgitee仓库：https://gitee.com/QQxiaoming/quard_star_tutorial本节所在tag：ch23 ...
linux中如何在fb上显示
嵌入式与人工智能
08-20 4966
framebuffer 帧缓冲 https://blog.csdn.net/readnap/article/details/83006523 帧缓冲（framebuffer）是Linux 系统为显示设备提供的一个接口，它将显示缓冲区抽象，屏蔽图像硬件的底层差异，允许上层应用程序在图形模式下直接对显示缓冲区进行读写操作。用户不必关心物理显示缓冲区的具体位置及存放方式，这些都由帧缓冲设备驱动本身来完成。 framebuffer机制模仿显卡的功能，将显卡硬件结构抽象为一系列的数据结构，可以通过fra...
linux tslib
09-28
引用:D:\Linux-4.9.88.tar\Linux-4.9.88\include\uapi\linux input.h 。 引用:cp -d lib/*so* /home/book/100ask_imx6ull-sdk/ToolChain/gcc-linaro-6.2.1-2016.11-x86_64_arm-linux-gnueabihf/bin/../arm-linux-gnueabihf/libc/usr/lib/ （2）板子上测试编译 。 引用:1，上网搞个源码库，如果你可爱到不会用百度，没关系，戳我下载（ http://download.csdn.net/detail/vincent040/9662825 ）。 2，将源代码丢到Ubuntu，并通过以下命令解压到Ubuntu的家目录下： tar xjvf tslib-1.4.tar.bz2 -C ~ 3，进入源码顶层目录，依次执行如下命令： mkdir ~/tslib ./configure --prefix=/home/xxx/tslib --host=arm-none-linux-gnueabi make make install A) --prefix= 后面的路径就是你要安装 tslib 库的路径，墙裂建议设置为家目录下的空目录（比如~/tslib），因为如果设置系统其它目录的话，后期 make install 的时候会让你解决权限的问题，当你自作聪明地使用sudo的时候，系统却又可能会抱怨找不到工具链，因此除非你是 Ubuntu科学家，对系统环境变量了如指掌，否则不要用小白的身份去作死，乖乖将 --prefix 指定为 ~/tslib 即可。 根据提供的引用内容，可以看出tslib是一个Linux上的触摸屏输入子系统库。它提供了在嵌入式系统中处理触摸屏输入的功能和接口。要安装tslib库，可以按照以下步骤进行操作：首先，下载源码库并将源代码解压到Ubuntu的家目录下；接着进入源码顶层目录，创建一个空目录（比如~/tslib）作为安装路径，并执行configure命令来配置安装参数；然后使用make命令编译源代码；最后使用make install命令安装tslib库到指定的安装路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值