04轨迹规划基础----正逆运动学的C++代码编写

最新推荐文章于 2023-11-13 13:48:10 发布
最新推荐文章于 2023-11-13 13:48:10 发布
阅读量6.8k 收藏 148
点赞数 43
分类专栏： ROS下UR机器人的轨迹规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44168457/article/details/113241613
版权

1.摘要

文章的主要内容是,编写C++代码，实现六轴机械臂的正运动学运算（输入为关节角度，输出为T6 ）和逆运动学求解（输入为T6，输出为关节角度），这个代码是很基础的，可能十几年前网上就有成熟的了，当然你也可以用我下边粘贴的代码。
本文数学公式截图来自论文

[1]张付祥,赵阳.UR5机器人运动学及奇异性分析[J].河北科技大学学报,2019,40(01):51-59.

2.DH参数表

DH参数表基于ur10机器人
在这里插入图片描述

3.正运动学

①数学公式
在这里插入图片描述
在这里插入图片描述
②

#include<iostream>
using namespace  std;
const double d1 = 0.1273;
const double a2 = 0.612;
const double a3 = 0.5723;
const double d4 = 0.163941;
const double d5 = 0.1157;
const double d6 = 0.0922;
const double ZERO_THRESH = 0.00000001;
int SIGN(double x)
{
    return (x > 0) - (x < 0);
}
const double PI = 3.1415926;
void forward(const double* q, double* T) {
    double s1 = sin(*q), c1 = cos(*q); q++;
    double q23 = *q, q234 = *q, s2 = sin(*q), c2 = cos(*q); q++;
    double s3 = sin(*q), c3 = cos(*q); q23 += *q; q234 += *q; q++;
    double s4 = sin(*q), c4 = cos(*q); q234 += *q; q++;
    double s5 = sin(*q), c5 = cos(*q); q++;
    double s6 = sin(*q), c6 = cos(*q);
    double s23 = sin(q23), c23 = cos(q23);
    double s234 = sin(q234), c234 = cos(q234);
   
    *T = c6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * s6; T++;  //nx
    *T = -s6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * c6; T++;  //Ox
    *T =-( c234 * c1 * s5 - c5 * s1); T++;//ax
    *T =- (d6 * c234 * c1 * s5 - a3 * c23 * c1 - a2 * c1 * c2 - d6 * c5 * s1 - d5 * s234 * c1 - d4 * s1); T++;//Px
    
    *T = -c6 * (c1 * s5 - c234 * c5 * s1) - s234 * s1 * s6; T++;//ny
    *T = s6 * (c1 * s5 - c234 * c5 * s1) - s234 * c6 * s1; T++;//Oy
    *T = -(c1 * c5 + c234 * s1 * s5); T++;//ay
    *T = -(d6 * (c1 * c5 + c234 * s1 * s5) + d4 * c1 - a3 * c23 * s1 - a2 * c2 * s1 - d5 * s234 * s1); T++;//py
    
    
    *T = -(-c234 * s6 - s234 * c5 * c6); T++;//nz
    *T = -(s234 * c5 * s6 - c234 * c6); T++;//oz
    *T = -s234 * s5; T++;//az
    *T = d1 + a3 * s23 + a2 * s2 - d5 * (c23 * c4 - s23 * s4) - d6 * s5 * (c23 * s4 + s23 * c4); T++;//Pz
    *T = 0.0; T++; *T = 0.0; T++; *T = 0.0; T++; *T = 1.0;//姿态
}

int main()
{
    double Q[6] = { 0.1, 0.2, 0.3, 0.4, 0.5, 0.6 };
    double t[4][4];
    double * T,*q;
    q = &Q[0];
    T = &t[0][0]; 
    forward(q, T);
    //输出q
    cout << "关节角度q:   " << "["  ;
    for (int i = 0; i < 6; i++) {cout << Q[i]<<"  ";}
    cout << "]"<<endl;    
    //输出JZ
    cout << "矩阵T:   " <<endl ;
    for (int i = 0; i < 4; i++) 
    { 
        for (int j = 0; j < 4; j++)
        {
            cout <<t[i][j]<<"      ";        }
        cout << endl;
    }
    return 0;
    }

运行结果：

关节角度q:   [0.1  0.2  0.3  0.4  0.5  0.6  ]
矩阵T:
0.0473957      -0.976785      -0.208915      1.18382
-0.392918      0.174058      -0.90295      -0.127305
0.918351      0.124882      -0.375547      0.416715
0      0      0      1

4.逆运动学

这个我应该码出来的，但是我家好冷，我的手已经僵了，我现在感觉我敲机械键盘像是敲缝纫机，所以我明天会将这个文章更新（PS：我写的逆运动学代码，肯定会比matlab自带的好用哦！）

好久没更新的，我今天上号我发现我多了几个粉丝！啊我好激动，我的动力来了！！！！
以下为逆运动学计算代码
①数学公式
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
接下求第2、3、4关节的时候有点复杂了，你可要看好了
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

#include<iostream>
using namespace  std;
const double d1 = 0.1273;
const double a2 = 0.612;
const double a3 = 0.5723;
const double d4 = 0.163941;
const double d5 = 0.1157;
const double d6 = 0.0922;
const double ZERO_THRESH = 0.00000001;
int SIGN(double x)
{
    return (x > 0) - (x < 0);
}
const double PI = 3.1415926;
void forward(const double* q, double* T) {
    double s1 = sin(*q), c1 = cos(*q); q++;
    double q23 = *q, q234 = *q, s2 = sin(*q), c2 = cos(*q); q++;
    double s3 = sin(*q), c3 = cos(*q); q23 += *q; q234 += *q; q++;
    double s4 = sin(*q), c4 = cos(*q); q234 += *q; q++;
    double s5 = sin(*q), c5 = cos(*q); q++;
    double s6 = sin(*q), c6 = cos(*q);
    double s23 = sin(q23), c23 = cos(q23);
    double s234 = sin(q234), c234 = cos(q234);
   
    *T = c6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * s6; T++;  //nx
    *T = -s6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * c6; T++;  //Ox
    *T =-( c234 * c1 * s5 - c5 * s1); T++;//ax
    *T =- (d6 * c234 * c1 * s5 - a3 * c23 * c1 - a2 * c1 * c2 - d6 * c5 * s1 - d5 * s234 * c1 - d4 * s1); T++;//Px
    
    *T = -c6 * (c1 * s5 - c234 * c5 * s1) - s234 * s1 * s6; T++;//ny
    *T = s6 * (c1 * s5 - c234 * c5 * s1) - s234 * c6 * s1; T++;//Oy
    *T = -(c1 * c5 + c234 * s1 * s5); T++;//ay
    *T = -(d6 * (c1 * c5 + c234 * s1 * s5) + d4 * c1 - a3 * c23 * s1 - a2 * c2 * s1 - d5 * s234 * s1); T++;//py
    
    
    *T = -(-c234 * s6 - s234 * c5 * c6); T++;//nz
    *T = -(s234 * c5 * s6 - c234 * c6); T++;//oz
    *T = -s234 * s5; T++;//az
    *T = d1 + a3 * s23 + a2 * s2 - d5 * (c23 * c4 - s23 * s4) - d6 * s5 * (c23 * s4 + s23 * c4); T++;//Pz
    *T = 0.0; T++; *T = 0.0; T++; *T = 0.0; T++; *T = 1.0;//姿态
}
int inverse(const double* T, double* q_sols,double * q) {
    int num_sols = 0;
    double T00 = *T; T++; double T01 = *T; T++; double T02 = *T; T++; double T03 = *T; T++;
    double T10 = *T; T++; double T11 = *T; T++; double T12 = *T; T++; double T13 = *T; T++;
    double T20 = *T; T++; double T21 = *T; T++; double T22 = *T; T++; double T23 = *T;
    double qq1, qq2, qq3, qq4, qq5, qq6;

    
    double q1[2];
    {
        double A = d6 * T12 - T13;
        double B = d6 * T02 - T03;
        double R = A * A + B * B;
        if (fabs(A) < ZERO_THRESH) {
            double div;
            if (fabs(fabs(d4) - fabs(B)) < ZERO_THRESH)
                div = -SIGN(d4) * SIGN(B);
            else
                div = -d4 / B;
            double arcsin = asin(div);
            if (fabs(arcsin) < ZERO_THRESH)
                arcsin = 0.0;
            if (arcsin < 0.0)
                q1[0] = arcsin + 2.0 * PI;
            else
                q1[0] = arcsin;
            q1[1] = PI - arcsin;
        }
        else if (fabs(B) < ZERO_THRESH) {
            double div;
            if (fabs(fabs(d4) - fabs(A)) < ZERO_THRESH)
                div = SIGN(d4) * SIGN(A);
            else
                div = d4 / A;
            double arccos = acos(div);
            q1[0] = arccos;
            q1[1] = 2.0 * PI - arccos;
        }
        else if (d4 * d4 > R) {
            return num_sols;
        }
        else {
            double arccos = acos(d4 / sqrt(R));
            double arctan = atan2(-B, A);
            double pos = arccos + arctan;
            double neg = -arccos + arctan;
            if (fabs(pos) < ZERO_THRESH)
                pos = 0.0;
            if (fabs(neg) < ZERO_THRESH)
                neg = 0.0;
            if (pos >= 0.0)
                q1[0] = pos;
            else
                q1[0] = 2.0 * PI + pos;
            if (neg >= 0.0)
                q1[1] = neg;
            else
                q1[1] = 2.0 * PI + neg;
        }
     
        qq1 = q1[1];
    }
    
    double q5[2][2];
    {
        for (int i = 0; i < 2; i++) {
            double numer = (T03 * sin(q1[i]) - T13 * cos(q1[i]) - d4);
            double div;
            if (fabs(fabs(numer) - fabs(d6)) < ZERO_THRESH)
                div = SIGN(numer) * SIGN(d6);
            else
                div = numer / d6;
            double arccos = acos(div);
            q5[i][0] = arccos;
            q5[i][1] = 2.0 * PI - arccos;
        }
        
        qq5 = q5[1][0];
    }
    
    {
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                double c1 = cos(q1[i]), s1 = sin(q1[i]);
                double c5 = cos(q5[i][j]), s5 = sin(q5[i][j]);
                double q6;
                
                if (fabs(s5) < ZERO_THRESH)
                    q6 = 0;
                else {
                    q6 = atan2(SIGN(s5) * -(T01 * s1 - T11 * c1),
                        SIGN(s5) * (T00 * s1 - T10 * c1));
                    if (fabs(q6) < ZERO_THRESH)
                        q6 = 0.0;
                    if (q6 < 0.0)
                        q6 += 2.0 * PI;
                }
                double q2[2], q3[2], q4[2];

                double c6 = cos(q6), s6 = sin(q6);
                double x04x = -s5 * (T02 * c1 + T12 * s1) - c5 * (s6 * (T01 * c1 + T11 * s1) - c6 * (T00 * c1 + T10 * s1));
                double x04y = c5 * (T20 * c6 - T21 * s6) - T22 * s5;
                double p13x = d5 * (s6 * (T00 * c1 + T10 * s1) + c6 * (T01 * c1 + T11 * s1)) - d6 * (T02 * c1 + T12 * s1) +
                    T03 * c1 + T13 * s1;
                double p13y = T23 - d1 - d6 * T22 + d5 * (T21 * c6 + T20 * s6);

                double c3 = (p13x * p13x + p13y * p13y - a2 * a2 - a3 * a3) / (2.0 * a2 * a3);
                if (fabs(fabs(c3) - 1.0) < ZERO_THRESH)
                    c3 = SIGN(c3);
                else if (fabs(c3) > 1.0) {
                    // TODO NO SOLUTION
                    continue;
                }
                double arccos = acos(c3);
                q3[0] = arccos;
                q3[1] = 2.0 * PI - arccos;
                double denom = a2 * a2 + a3 * a3 + 2 * a2 * a3 * c3;
                double s3 = sin(arccos);
                double A = (a2 + a3 * c3), B = a3 * s3;
                q2[0] = atan2((A * p13y - B * p13x) / denom, (A * p13x + B * p13y) / denom);
                q2[1] = atan2((A * p13y + B * p13x) / denom, (A * p13x - B * p13y) / denom);
                double c23_0 = cos(q2[0] + q3[0]);
                double s23_0 = sin(q2[0] + q3[0]);
                double c23_1 = cos(q2[1] + q3[1]);
                double s23_1 = sin(q2[1] + q3[1]);
                q4[0] = atan2(c23_0 * x04y - s23_0 * x04x, x04x * c23_0 + x04y * s23_0);
                q4[1] = atan2(c23_1 * x04y - s23_1 * x04x, x04x * c23_1 + x04y * s23_1);
                qq6 = q6;
                qq2 = q2[0];
                qq3 = q3[0];
                qq4 = q4[0];
                num_sols++;
                }

            }
        }
    }
    *q = qq1; q++; *q = qq2; q++; *q = qq3; q++; *q = qq4; q++; *q = qq5; q++; *q = qq6; 

    return num_sols;
}

int main()
{
    double Q[6] = { 1, 0.2, 0.3, 0.4, 0.5, 0.8 };
    double t[4][4];
    double Qs[6] = { 0, 0, 0, 0, 0, 0 };
    double * T,*q,*qq;
    q = &Q[0];
    T = &t[0][0];  
    qq = &Qs[0];
    double q_sols[48];
    int num_sols;
    //逆运动学    
    forward(q, T);
    //输出初始的关节角度q
    cout << "输出初始的关节角度q:   " << "["  ;
    for (int i = 0; i < 6; i++) {cout << Q[i]<<"  ";}
    cout << "]"<<endl;    
    //输出由q 进行正运动学结果T
    cout << "输出由q 进行正运动学结果T:   " <<endl ;
    for (int i = 0; i < 4; i++) 
    { 
        for (int j = 0; j < 4; j++) 
        {
            cout <<t[i][j]<<"      ";
        }
        cout << endl;

    }
    num_sols = inverse(T, q_sols, qq);
    //输出由T输入 进行逆运动学得到的结果qq
    cout << "输出由T输入 进行逆运动学得到的结果qq:   " << "[";
    for (int i = 0; i < 6; i++) { cout << Qs[i] << "  "; }
    cout << "]" << endl;
    return 0;
}

结果：

输出初始的关节角度q:   [1  0.2  0.3  0.4  0.5  0.8  ]
输出由q 进行正运动学结果T:
0.182807      -0.795703      0.577442      0.835595
-0.333502      -0.602703      -0.724931      0.848183
0.924856      -0.0600552      -0.375547      0.416715
0      0      0      1
输出由T输入 进行逆运动学得到的结果qq:   [1  0.2  0.3  0.4  0.5  0.8  ]

5预告

下一篇应该在明天或者后天：关于插值的c++代码/c++中姿态的图像表述
（先后顺序还没想好）
这篇文写了两天，所以中间有很多碎碎叨叨的话，我就不删了哦，代码运行有问题可以私戳我
我写的好认真，然后我发现有粉丝好开心，所以我就过分的设置成仅粉丝可见了，原谅我的虚荣，我的指针用的还不太熟，所以代码不够高级，请见谅~

我爱编程皮肤好好
关注
  • 43
    点赞
  • 踩
  • 148
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
深入探讨机械臂圆弧轨迹规划及其在C++中的实现
m0_57781768的博客
06-11 726
机械臂轨迹规划是指通过算法计算机械臂从初始位置到目标位置的运动路径。在工业机器人中，轨迹规划至关重要，因为它直接影响到机器人执行任务的准确性和效率。常见的轨迹类型包括直线轨迹和圆弧轨迹。double y;private:public:++i) {Point表示平面上的一个点，表示圆弧轨迹。类包含生成轨迹的逻辑，并返回一系列点作为轨迹。在本篇博客中，我们详细介绍了机械臂圆弧轨迹规划的基本原理，并通过MATLAB和C++实现了这一功能。
五自由度机械臂正逆运动学算法（Ｃ语言+Matlab）
热门推荐
xuuyann
07-13 2万+
/* * MyMatrix.h * * Created on: Jul 13, 2019 * Author: xuuyann */ #ifndef HEADER_MYMATRIX_H_ #define HEADER_MYMATRIX_H_ typedef struct MNode *PtrToMNode; struct MNode { int row; int col...
机械臂运动学C++代码
07-22
该文件包含机械臂运动学公式推导，包含机械臂建模、运动学正解、运动学逆解。代码全是用c++写的，代码已经过验证。
六轴机械臂时间能量冲击最优轨迹规划 轨迹优化 支持最高7次NURBS 默认7次 可修改成其他阶数 扩展性强
HBWUuzQrm的博客
11-13 771
轨迹优化的目的是为了最大化机械臂的运动能量，同时减小机械臂的冲击力和振动，从而保证机械臂运动的快速、平稳、高效。在该算法中，我们将机械臂的关节位置、关节速度、关节加速度视为优化变量，通过多目标规划的方法，生成pareto最优解集图，可以非常方便地评估轨迹的优劣性，并且可以用于复现浙大机械手多目标轨迹规划的实验结果，使得该算法的收敛速度更加快速。总之，六轴机械臂时间能量冲击最优轨迹规划是一项非常重要的技术，可以提高机械臂的运动效率和稳定性，进而提高生产效率和质量。六轴机械臂时间能量冲击最优轨迹规划。
机械臂速成小指南（十二）：逆运动学分析
刘躺的博客
07-07 1万+
在指南（九）中我们已得出关节变量与末端执行器位姿的函数关系，即正运动学方程。但在实际应用中，我们往往需要通过给定的末端执行器位姿来解算相应的关节变量，以此来确定各关节旋转角度，进而控制机械臂完成在空间中的运动。 一、机械臂的逆解个数........................
六轴UR机械臂正逆运动学求解_MATLAB代码（标准DH参数表）
u011158127的博客
08-09 4942
六轴UR机械臂正逆运动学
（6）六轴机械臂的运动学正、逆解
rouyu308的博客
06-01 2万+
下面在前面的ur5机械臂的DH参数基础是对其正逆解进行求解，为了后面能在MATLAB中利用stl文件进行实际显示，这里以标准DH参数为例进行讲解。（修正DH参数在用plot3d函数是显示失败，不知道是不是这个函数只能显示标准dh参数的机械臂模型，有知道的网友可以在评论里告知一下，谢谢。） 一、运动学正解： 机器人正运动学是在已知各连杆相对位置关系（关节角）的情况下，得到末端执行器的位姿。在标准DH参数下相邻坐标系之间的齐次变换矩阵为： 则，正解代码如下： function [T06,P.
7DOF-Trajectory planning_轨迹规划_轨迹_trajectoryplanning_7自由度_traject
10-05
7DOF机器人的轨迹规划还涉及到逆动力学计算，因为需要将规划出的轨迹转化为每个关节的实际运动指令。逆动力学计算通常很复杂，需要处理非线性和约束问题。此外，为了保证运动的平滑性，可能还需要考虑轨迹的二次导数...
UR六轴机械臂c、python源码+webots仿真
最新发布
03-07
在这个项目中，我们将深入探讨相关知识点，包括运动学正解、逆解以及轨迹规划，同时也涉及编程语言的应用。 一、运动学分析 运动学是研究机械系统位置、速度和加速度变化的学科，对于机械臂来说，主要分为两部分：...
工业机器人虚拟仿真--源文件--发稿.zip
06-24
在这个压缩包中，我们可能会找到由专业开发者编写的C++、Python、MATLAB或其他编程语言的代码，这些代码可能涉及机器人运动学、动力学、控制算法以及图形用户界面等方面。 首先，工业机器人虚拟仿真的核心技术之一...
6轴工业机械臂运动学算法（C++）.zip_6轴算法 c++_dotxir_warmuts_六轴机械臂_机械臂
07-14
六轴机械臂运动学源码，个人还是初学者，如有错误，勿喷
标准6自由度机器人程序-源代码
06-06
6-DOF机器人的程序设计通常涉及到复杂的数学计算，如向量和矩阵运算、逆运动学解算、动力学模型建立以及路径规划等。下面将详细探讨这些关键知识点。 1. **向量和矩阵运算**：在6-DOF机器人的运动控制中，向量和...
UR3运动学正解和逆解的C++实现
Studying……
01-13 1559
//正解 void forward(const double* q, double* T) { double s1 = sin(*q), c1 = cos(*q); q++; double q234 = *q, s2 = sin(*q), c2 = cos(*q); q++; double s3 = sin(*q), c3 = cos(*q); q234 += *q...
【轨迹规划】贝塞尔曲线理解及C++实现n次贝塞尔曲线
weixin_45650767的博客
03-29 5175
原理：基于控制点的概念，通过控制点来定义曲线的形状，控制点的坐标决定了曲线的起始点、终止点以及曲线在这些点和它们之间的形状。给出C++实现代码，和matlab画图方法
6轴机器人运动学正解,逆解1
ace2008888的博客
06-27 3701
正解 给定机器人各关节的角度，计算出机器人末端的空间位置 逆解 已知机器人末端的位置和姿态，计算机器人各关节的角度值 常见的工业机器人 正解与逆解的求解需要相应的机器人运动方程，其中关键的就是DH参数表 DH参数表用来描述机器人各关节坐标系之间的关系，有了DH参数表就可以在机器人各关节之间进行坐标转换 求解正解就是从关节1到关节5的坐标转换 基本知识 关节：连接2个杆件的部分...
机器人建模中移动关节如何建立坐标系_机器人工程师进阶之路（三）6轴机械臂DH法下的变换关系...
weixin_39573136的博客
11-21 1106
DH法下的变换关系上一篇我们利用两种DH法对6轴机械臂进行了建模。本篇将介绍两种DH法下的变换关系。我们在建模时已知是按照一定的顺序将相邻的坐标系进行变换的。SDH的顺序是。MDH的顺序是。所以根据以上顺序，通过右乘表示四个运动的四个矩阵就可以得到变换矩阵A，A表示了四个依次的运动。由于所有变换都是相对于当前坐标系的，因此所有的矩阵都是右乘的。从而得到两个变换矩阵：1）SDH2）MDH则机器人的基...
机械臂学习——舵机的速度控制、坐标变换、DH模型、正运动学解、逆运动学解
戚晨夕的博客
02-07 1万+
机械臂学习 文章目录机械臂学习前言一、舵机的速度控制1.舵机概述2.代码实现二、机械臂的坐标变换1.坐标变换2.坐标的几何概述三、DH模型和正运动学解总结 前言 舵机工作原理： 通过单片机产生PWM信号控制舵机。 一、舵机的速度控制 1.舵机概述 工作电压：4.8v-6v 舵机的驱动是比较容易的，当我们使用单片机控制的时候，通过输出50HZ（20ms的周期）的PWM，控制PWM脉宽调节舵机的转角。舵机的转角与脉宽（高电平时间）存在一一对应关系，如果控制舵机转到某一角度，就改变输出脉宽即可，比如从1ms到
【MATLAB】5DOFs机械臂运动学正逆解（MDH）-解析法实现
qq_43557907的博客
01-26 1万+
引言 本篇文章是记录我个人在学习机械臂时的一些想法，如果各位有发现某些错误，麻烦在评论区批评或指出，我会第一时间改正，谢谢。 （后续更新：轨迹规划与Python移植。） 一、MDH建立： 对于某宝上常见的5DOFs机械手臂，应用MDH参数可建立如下坐标系： Frames: MDH参数表： i alphai-1 ai-1 di thetai 1 0 0 0 theta1 2 -pi/2 0 0 theta2 3 0 L2 0 theta3 4 0 L3 0 theta4 5 -
用C++编写一段代码，输出1-100的和
04-22
好的，以下是用C语言编写的输出1-100的和的代码： ```c #include <stdio.h> int main() { int sum = 0; for(int i = 1; i <= 100; i++) { sum += i; } printf("1到100的和为：%d\n", sum); return 0; } ``` 注意：该代码只是输出了1-100的和，并没有涉及到人工智能等相关话题。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我爱编程皮肤好好

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

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

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

打赏作者

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

抵扣说明：

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

余额充值