2023电赛E题激光打靶图像部分开源

已于 2023-08-29 12:29:03 修改
阅读量617 收藏 13
点赞数 3
分类专栏： 大学竞赛 文章标签： 开源 人工智能 单片机 嵌入式硬件
于 2023-08-09 23:51:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62634962/article/details/132199971
版权

方案：将摄像头中心与激光中心重合，通过矩形四角点坐标计算出边的斜率、直线方程等，进而规划出激光下一个理想坐标，方法如下

import sensor, image, time ,math,pyb
from pyb import Servo
from pid import PID
from pyb import UART

# 设置阈值用于二值化

threshold_val = (100, 255)  # 根据实际情况调整阈值
enable_lens_corr = False # turn on for straighter lines...打开以获得更直的线条…

#roi1 =(20, 20, 109, 85)
k=[0,0,0,0]
l1=3
point=[[0,0],[0,0],[0,0],[0,0]]
i=0
u=0
t1=0
t2=0
t3=0
t4=0
flag=0
flag_p=0

l2=0
l3=0
l4=0
xp=0
yp=0
k2=0
count=0
square1=[0,0,0,0,0,0,0]
square2=[0,0,0,0,0,0,0]
square3=[0,0,0,0,0,0,0]
square4=[0,0,0,0,0,0,0]
erro_x=0
erro_y=0
px1=0
py1=0
len1=0
sum=0

# 初始化摄像头
sensor.reset()
sensor.set_pixformat(sensor.RGB565)  # 设置图像格式为灰度
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time=2000)  # 等待摄像头稳定
sensor.set_auto_gain(False)
sensor.set_auto_whitebal(False)
uart = UART (3, 115200)

while True:
    img = sensor.snapshot().lens_corr(strength = 1.8, zoom = 1.3)

    if enable_lens_corr: img.lens_corr(1.8)
    img.draw_circle( 80, 60 , 1, color = (255,0,0),fill=True)
    img.draw_circle( 80, 60 , 1, color = (255,0,0),fill=True)
    for r in img.find_rects(threshold = 30000):
        #img.draw_rectangle(r.rect(), color = (255, 0, 0))
        for p in r.corners():

            #img.binary([threshold_val])
            #if((point[i][0]<=0) or (point[i][1]<=0) or (point[i][0]>=159) or (point[i][1]>=159)):
                #point[i][0]=0
                #point[i][1]=0

            #else:
                #point[i][0]=p[0]
                #point[i][1]=p[1]
            point[i][0]=p[0]
            point[i][1]=p[1]

            if(i==3):

                img.draw_circle(p[0], p[1], 3, color = (155, 0, 255),fill=True)
            if(i!=3):
                img.draw_circle(p[0], p[1], 2, color = (0, 0, 255),fill=True)

            if (point[3][0]>0):
                k[i]=((point[(i+1)%4][1]-point[i][1])/(point[(i+1)%4][0]-point[i][0]+0.0001))
            if(i==1):
                point[i][0]=point[i][0]-3
                point[i][1]=point[i][1]-3
            if(i==2):
                point[i][0]=point[i][0]-3
                point[i][1]=point[i][1]+3
            if(i==3):
                point[i][0]=point[i][0]+4
                point[i][1]=point[i][1]+4
            if(i==0):
                point[i][0]=point[i][0]
                point[i][1]=point[i][1]

                #point[i][0]=p[0]-4/(math.sqrt(1+k[2]*k[2]))
                #point[i][1]=p[1]-(4*k[i])/(math.sqrt(1+k[0]*k[0]))

            i=i+1
            if (i == 4) :
                i=0


   # print(k[0],k[1],k[2],k[3])
    if(flag==0 and point[0][0]>0 and point[0][1]>0):
        erro_x=80-point[3][0]
        erro_y=60-point[3][1]
        print(point[3][0]*1.0,point[3][1]*1.0)
        uart.write('%')
        uart.write(str(len(str(point[3][0]*1.0))))
        uart.write(str(point[3][0]*1.0))
        uart.write(str(len(str(point[3][1]*1.0))))
        uart.write(str(point[3][1]*1.0))
        uart.write('&')


    if(flag==0 and math.sqrt(erro_x*erro_x+erro_y*erro_y)<1):
        flag=1##循迹开始
        erro_x=0
        erro_y=0


     #   3   k2   2
     #   ----------
     #   |        |
     #   |        |
     #k3 |        | k1
     #   |        |
     #   |        |
     #   |        |
     #   ----------
     #   0   k0   1

    if(flag==1):#循迹部分
        erro_x=80-point[2][0]
        erro_y=60-point[2][1]
        #if(math.sqrt(erro_x*erro_x+erro_y*erro_y)>0):
        #xp1=-1*(point[3][0]-80)
        #yp1=-1*(point[3][1]-60)
        #xp=(l1/math.sqrt(1+k[2]*k[2]))+(k[2]*k[2]*xp1-yp1*k[2])/(1+k[2]*k[2])
        #yp=(l1*k[2])/math.sqrt(1+k[2]*k[2])+(yp1-k[2]*xp1)/(1+k[2]*k[2])



        xp1=k[2]*k[2]+1

        yp=((80*k[2]+(60-point[3][1])*(xp1-1)-point[3][0]*k[2])/xp1+point[3][1])+(l1*k[2])/math.sqrt(xp1)

        xp=(((xp1-1)*point[3][0]+80+(60-point[3][1])*k[2])/xp1)+(l1)/math.sqrt(xp1)

        img.draw_circle( int(xp), int(yp) , 2, color = (0,255,0),fill=True)


        img.draw_line((int(point[3][0]),int(point[3][1]),int(point[2][0]),int(point[2][1])), color = (255,255,0))
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)>10):
            print(round(xp,1),round(yp,1))
            uart.write('%')

            uart.write(str(len(str(round(xp,1)))))
            uart.write(str(round(xp,1)))
            uart.write(str(len(str(round(yp,1)))))
            uart.write(str(round(yp,1)))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<=10 and math.sqrt(erro_x*erro_x+erro_y*erro_y)>=2):
            print(point[2][0]*1.0,point[2][1]*1.0)
            uart.write('%')
            uart.write(str(len(str(point[2][0]*1.0))))
            uart.write(str(point[2][0]*1.0))
            uart.write(str(len(str(point[2][1]*1.0))))
            uart.write(str(point[2][1]*1.0))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<2):
            flag=2
            erro_x=0
            erro_y=0

    if(flag==2):#循迹部分
        erro_x=80-point[1][0]
        erro_y=60-point[1][1]
        xp1=k[1]*k[1]+1
        if(k[1]>=0):

            yp=((80*k[1]+(60-point[2][1])*(xp1-1)-point[2][0]*k[1])/xp1+point[2][1])+(l1*k[1])/math.sqrt(xp1)

            xp=(((xp1-1)*point[2][0]+80+(60-point[2][1])*k[1])/xp1)+(l1)/math.sqrt(xp1)
        if(k[1]<0):
            yp=((80*k[1]+(60-point[2][1])*(xp1-1)-point[2][0]*(k[1]))/xp1+point[2][1])-(l1*(k[1]))/math.sqrt(xp1)

            xp=(((xp1-1)*point[2][0]+80+(60-point[2][1])*k[1])/xp1)-(l1)/math.sqrt(xp1)
        img.draw_circle( int(xp), int(yp) , 2, color = (255,255,0),fill=True)

        img.draw_line((int(point[1][0]),int(point[1][1]),int(point[2][0]),int(point[2][1])), color = (255,255,0))

        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)>10):
            print(round(xp,1),round(yp,1))
            uart.write('%')

            uart.write(str(len(str(round(xp,1)))))
            uart.write(str(round(xp,1)))
            uart.write(str(len(str(round(yp,1)))))
            uart.write(str(round(yp,1)))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<=10 and math.sqrt(erro_x*erro_x+erro_y*erro_y)>=2):
            print(point[1][0]*1.0,point[1][1]*1.0)
            uart.write('%')
            uart.write(str(len(str(point[1][0]*1.0))))
            uart.write(str(point[1][0]*1.0))
            uart.write(str(len(str(point[1][1]*1.0))))
            uart.write(str(point[1][1]*1.0))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<2):
            flag=3
            erro_x=0
            erro_y=0

    if(flag==3):#循迹部分
        erro_x=80-point[0][0]
        erro_y=60-point[0][1]
        xp1=k[0]*k[0]+1

        yp=((80*k[0]+(60-point[1][1])*(xp1-1)-point[1][0]*k[0])/xp1+point[1][1])-(l1*k[0])/math.sqrt(xp1)

        xp=(((xp1-1)*point[1][0]+80+(60-point[1][1])*k[0])/xp1)-(l1)/math.sqrt(xp1)
        img.draw_circle( int(xp), int(yp) , 2, color = (255,255,0),fill=True)

        img.draw_line((int(point[1][0]),int(point[1][1]),int(point[0][0]),int(point[0][1])), color = (255,255,0))

        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)>10):
            print(round(xp,1),round(yp,1))
            uart.write('%')

            uart.write(str(len(str(round(xp,1)))))
            uart.write(str(round(xp,1)))
            uart.write(str(len(str(round(yp,1)))))
            uart.write(str(round(yp,1)))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<=10 and math.sqrt(erro_x*erro_x+erro_y*erro_y)>=2):
            print(point[0][0]*1.0,point[0][1]*1.0)
            uart.write('%')
            uart.write(str(len(str(point[0][0]*1.0))))
            uart.write(str(point[0][0]*1.0))
            uart.write(str(len(str(point[0][1]*1.0))))
            uart.write(str(point[0][1]*1.0))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<2):
            flag=4
            erro_x=0
            erro_y=0

    if(flag==4):#循迹部分
        erro_x=80-point[3][0]
        erro_y=60-point[3][1]
        xp1=k[3]*k[3]+1
        if(k[3]>=0):
            yp=((80*k[3]+(60-point[0][1])*(xp1-1)-point[0][0]*k[3])/xp1+point[0][1])-(l1*k[3])/math.sqrt(xp1)

            xp=(((xp1-1)*point[0][0]+80+(60-point[0][1])*k[3])/xp1)-(l1)/math.sqrt(xp1)
        if(k[3]<0):
            yp=((80*k[3]+(60-point[0][1])*(xp1-1)-point[0][0]*(k[3]))/xp1+point[0][1])+(l1*(k[3]))/math.sqrt(xp1)

            xp=(((xp1-1)*point[0][0]+80+(60-point[0][1])*k[3])/xp1)+(l1)/math.sqrt(xp1)
        img.draw_circle( int(xp), int(yp) , 2, color = (255,255,0),fill=True)


        img.draw_line((int(point[3][0]),int(point[3][1]),int(point[0][0]),int(point[0][1])), color = (255,101,255))

        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)>10):
            print(round(xp,1),round(yp,1))
            uart.write('%')

            uart.write(str(len(str(round(xp,1)))))
            uart.write(str(round(xp,1)))
            uart.write(str(len(str(round(yp,1)))))
            uart.write(str(round(yp,1)))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<=10 and math.sqrt(erro_x*erro_x+erro_y*erro_y)>=2):
            print(point[3][0]*1.0,point[3][1]*1.0)

            uart.write('%')
            uart.write(str(len(str(point[3][0]*1.0))))
            uart.write(str(point[3][0]*1.0))
            uart.write(str(len(str(point[3][1]*1.0))))
            uart.write(str(point[3][1]*1.0))
            uart.write('&')
        if(math.sqrt(erro_x*erro_x+erro_y*erro_y)<2):
            flag=5
            erro_x=0
            erro_y=0


    if(flag==5):#循迹部分
            print('end!')
            uart.write('%')
            uart.write('4')
            uart.write('80.0')
            uart.write('4')
            uart.write('60.0')
            uart.write('&')

            img.draw_string(5,17,"CYT,YOU ARE SOOO HANDSOME",color = (255, 0, 255), scale=1.1,x_spacing=-2)








######################################################################################
    #print(point[0][0],point[0][1])
    #print(point[1][0],point[1][1])
    #print(point[2][0],point[2][1])
    #print(point[3][0],point[3][1])
    #print(k[0],k[1],k[2],k[3])




    #square1=[img.get_pixel(point[0][0]+1,point[0][1]+1),img.get_pixel(point[0][0]-1,point[0][1]-1),img.get_pixel(point[0][0],point[0][1]-1),img.get_pixel(point[0][0]-1,point[0][1]),
    #img.get_pixel(point[0][0]+1,point[0][1]),img.get_pixel(point[0][0],point[0][1]+1),img.get_pixel(point[0][0],point[0][1])]
    #square2=[img.get_pixel(point[1][0]+1,point[1][1]+1),img.get_pixel(point[1][0]-1,point[1][1]-1),img.get_pixel(point[1][0],point[1][1]-1),img.get_pixel(point[1][0]-1,point[1][1]),
    #img.get_pixel(point[1][0]+1,point[1][1]),img.get_pixel(point[1][0],point[1][1]+1),img.get_pixel(point[1][0],point[1][1])]
    #square3=[img.get_pixel(point[2][0]+1,point[2][1]+1),img.get_pixel(point[2][0]-1,point[2][1]-1),img.get_pixel(point[2][0],point[2][1]-1),img.get_pixel(point[2][0]-1,point[2][1]),
    #img.get_pixel(point[2][0]+1,point[2][1]),img.get_pixel(point[2][0],point[2][1]+1),img.get_pixel(point[2][0],point[2][1])]
    #square4=[img.get_pixel(point[3][0]+1,point[3][1]+1),img.get_pixel(point[3][0]-1,point[3][1]-1),img.get_pixel(point[3][0],point[3][1]-1),img.get_pixel(point[3][0]-1,point[3][1]),
    #img.get_pixel(point[3][0]+1,point[3][1]),img.get_pixel(point[3][0],point[3][1]+1),img.get_pixel(point[3][0],point[3][1])]
    #if(k[3]>0):
        #count=count+1
        #if(count>200):
            #t1=((square1[0]+square1[1]+square1[2]+square1[3]+square1[4]+square1[5]+3*square1[6])/255)
            #t2=((square2[0]+square2[1]+square2[2]+square2[3]+square2[4]+square2[5]+3*square2[6])/255)
            #t3=((square3[0]+square3[1]+square3[2]+square3[3]+square3[4]+square3[5]+3*square3[6])/255)
            #t4=((square4[0]+square4[1]+square4[2]+square4[3]+square4[4]+square4[5]+3*square4[6])/255)
            #count=205
    #print(square1[0],square1[1],square1[2],square1[3],count)
    #print(point[0][0],point[0][1])
    #print(point[1][0],point[1][1])
    #print(point[2][0],point[2][1])
    #print(point[3][0],point[3][1])

效果如下

若有错漏，欢迎指正

eTao_757
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
2023年电子设计大赛E题，基于STM32F103C8T6，使用CubeMX+EIDE(VS Code)开发.zip
08-22
全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。 全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。
2023电赛E题 记实开发 已开源 附带源码+MATLAB算法仿真
qq_35452794的博客
08-07 2898
可知在 k210 进行 QVGA 分辨率的图片识别时，由于分辨率较小，所截取的像素点较小，在进行 Harris 角点检测算法时误差最小是的范围是 0.7-0.8，误差为 1，在进行 Shi-Tomasi 角点检测算法时误差最小是的范围是 0.7 左右，误差为 8，在进行 FAST 角点检测算法时误差最小是的范围是 7-9，误差为 1，而在8 是误差为 0。首先进行当前坐标的获取。方案二： Shi-Tomasi 算法，是对 Harris 角点检测算法的升级版，是针对 R值的计算公式进行了优化和修改。
Openmv矩形识别+云台激光运动控制+激光跟踪（以2023电赛E题为例）上篇跟踪部分
weixin_62004449的博客
09-07 1万+
2023电赛E题追踪部分在实现中的问题以及解决方法。
【2023年电赛国一必备】E题报告模板--可直接使用
牧子川的博客
08-04 1万+
使用K210进行实现，并按照要求编写文档
基于MSP432P401R激光打靶【2023年电赛E题】
Bit_Dong的博客
08-15 3367
阅读题后可知，屏幕的高度和位置都是自定的，且在摆放完成后不再改变 以及需要自带屏幕，而激光发射点是自定的，也就是你可以在距屏幕外的1m处任意改变摆放位置，但在摆放完成后不再改变，此题不限板子，stm32、树莓派、TI任选即可。由题知，该题为目标点置位，也就是将红激光点复位至屏幕中心处，屏幕、激光位置都是已知的，我的建议是测出中心点相对于激光的角度位置，直接通过按下置位按钮，俩舵机转向相应角度，即激光指向屏幕中心，第一题就此完成。简单来说，只需将绿色激光笔在不同位置指向红色激光笔的置位点即可。
2023年电赛E题完整设计暨电赛全记录
qq_32971095的博客
08-07 1万+
2023年E题完整设计 “愿大家都少走弯路，在迷茫时看到希望！
电赛 2023运动目标控制与自动追踪系统（E题）-激光打靶（全套资料）
最新发布
07-30
电赛 2023运动目标控制与自动追踪系统（E题）----激光打靶（全套资料），非常优秀的资源！ 电赛 2023运动目标控制与自动追踪系统（E题）----激光打靶（全套资料），非常优秀的资源！ 电赛 2023运动目标控制与自动...
电赛e题报告分析
wwwwwcs的博客
08-11 829
本文使用K210芯片设计了一个运动目标控制与自动追踪系统。系统包括红色光斑位置控制和绿色光斑自动追踪，通过独立的二维电控云台和K210摄像头实现。基本要求包括光斑位置复位和运动目标控制，通过A4靶纸测试。发挥部分实现一键启动自动追踪和重复测试。系统利用CanMv实现图像处理和舵机运动控制功能，保证光斑控制系统相互独立且无通信。最终目标是实现自动追踪功能，并具备暂停键和测量光斑距离的能力。本设计可应用于各种需要目标追踪的场景，具有较高的实用性和可扩展性。
基于STM32F1激光视觉打靶
05-28
基于STM32F1激光视觉打靶，测试平台为STM32F103ZE6开发版，使用OV7670摄像头，按照要求连线后，可以在LCD屏上看到OV7670二值化后的图像，并且可以根据图像绘制框格，调动舵机驱动摄像头追踪激光的光束，实测可以，...
基于89C2051单片机的激光打靶信号处理系统设计.doc
10-19
激光打靶系统由半导体激光枪、光电探测器和信号处理电路三部分构成。激光枪发射出激光脉冲，这些脉冲被光电探测器捕获。光电探测器通常由多个单元组成，每个单元对应不同的编号，以便根据激光击中的位置判断打靶结果...
2023电赛开源参考程序
08-26
历年试题、经验分享、代码程序资源--2023电赛E题开源参考程序： 包含：小车摄像头3D模型、舵机激光棒平台模型等
2023全国大学生电子设计竞赛E题.zip
08-22
全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。 全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。
2023年电子设计大赛E题基于openmv与stm32的追踪云台
08-02
运动目标控制与自动追踪系统（E 题） 【本科组】 设计制作一个运动目标控制与自动追踪系统。系统包括模拟目标运动的红色 光斑位置控制系统和指示自动追踪的绿色光斑位置控制系统。系统结构示意及摆 放位置见图 1（a）。图中两个激光笔固定在各自独立的二维电控云台上。 红色激光笔发射的光斑用来模拟运动目标，光斑落在正前方距离 1m 处的白 色屏幕上，光斑直径≤1cm。红色光斑位置控制系统控制光斑能在屏幕范围内任 意移动。 绿色激光笔发射的光斑由绿色光斑位置系统控制，用于自动追踪屏幕上的红 色光斑，指示目标的自动追踪效果，光斑直径≤1cm。绿色激光笔放置线段如
23电赛E题.zip
08-21
全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。 全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。
激光打靶_基础版_最终版.rar
07-15
基于STM32的激光打靶代码，激光点坐标采用open mv采集。驱动电机采用180度舵机，在原有要求上做了难度增加，可以打任意方向任意和任意环数的靶。
【电设控制与图像训练题】【激光打靶】【opencv测试代码以及效果】
hanhan的博客
09-01 4408
规则 激光枪自动射击装置（E题） 【本科组】 一、任务 设计一个能够控制激光枪击发、自动报靶及自动瞄准等功能的电子系统。该系统由激光枪及瞄准机构、胸环靶、弹着点检测电路组成，其结构示意见图1。 二、要求 1．基本要求 （1） 用激光笔改装激光枪，激光枪可受电路控制发射激光束，激光束照射于胸环靶上弹着点的光斑直径＜5mm；激光枪与胸环靶间距离为3m。 图1 激光枪自动射击装置示意图 （2） 激光枪固定在一机构上，可通过键盘控制激光枪的弹着点（用键盘设置激光束在靶纸上上下、左右
电赛国一学长教你2023电赛E题矩形检测与追踪控制
技术宅学长的博客
08-04 2654
我分析一下题目，本来以为一二问呢很简单，第一问就是复位，第二问因为看到铅笔画的线，第一感觉应该是不用识别的，所以就开环控制，程序写死就行了。说一下发挥部分，发挥部分就是一个追踪一个点的问题，识别到红灯，设为目标位置，然后控制绿灯追红等，距离小于阈值，就发出声光。舵机控制部分我提供了32的代码，也提供了openmv与32通信的代码，pid部分我也公开了我当年的参赛作品板球系统的源代码，当然也是仅供参考，你别问我怎么不给你组合起来，那是我都给你做了，你做什么？首先根据这两天的观察，E题做的人是很多的。
2023电赛E题视觉部分OpenMV
weixin_68704893的博客
08-13 1863
OpenMV解决2023年电赛视觉基础部分。
2023年电赛---运动目标控制与自动追踪系统（E题）OpenART mini的代码移植到OpenMV
热门推荐
在嵌入式嵌入式领域奋斗的程序猿的博客
08-03 2万+
2023年电赛---运动目标控制与自动追踪系统（E题）OpenART mini的代码移植到OpenMV
2012年电赛激光打靶openmv
07-30
2012年电赛激光打靶openmv是一项电子比赛中的创新项目。该项目利用了激光技术和OpenMV计算机视觉系统，以实现自动打靶的目标。 激光打靶是一项常见的射击运动，参赛者需要尽可能准确地击中靶子。而OpenMV是一种基于...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值