精华内容
下载资源
问答
  • 六自由度机器人运动学正反求解过程,十分详细,机器人运动学
  • Delta Robot Kinematics 并联机器人 运动学 正解 本人自己总结 matlab亲测 正反正确
  • 采用机器人D-H坐标变换法,建立了PUMA560机器人运动学正解的数学模型。借助AutoCAD平台对工件中心位置和姿态进行测量,使得数学模型和CAD运动仿真得到了较全面的相互验证,对工业机器人运动性能研究具有积极意义。
  • 牛顿迭代求解串联机器人运动学正解
  • 基于改进DH参数的机器人正解和逆程序,逆采用解析形式,输出8组关节角度
  • 关于机器人运动学正解网上和机器人相关书籍上都是通过建立连杆坐标系和DH参数推导出来的,推导过程比较繁琐,本人不是从事机器人专业,我在推导机器人运动学正解的时候还不知道有DH参数一说,我的算法原理是运用...
    • 关于机器人运动学正解网上和机器人相关书籍上都是通过建立连杆坐标系和DH参数推导出来的,推导过程比较繁琐,本人不是从事机器人专业,我在推导机器人运动学正解的时候还不知道有DH参数一说,我的算法原理是运用计算机图形学中三维几何变换矩阵推导的,过程比较直观,通俗易懂。

    我们知道,三维空间中平移(tx,ty,tz)距离对应的齐次变换矩阵为:                                   

    绕x轴旋转θ角对应的矩阵为:

    绕y轴旋转θ角对应的矩阵为:                     

    绕z轴旋转θ角对应的矩阵为: 

    机器人各个关节的运动无非是绕某个轴线旋转,因此我们可以利用上面4个矩阵来推导机器人运动学正解。

    首先给出机器人的结构模型:

    我们发现,轴1其实绕z轴旋转,因此轴1对应的旋转矩阵为:

    轴2是绕平行于y轴的一个轴线旋转,这里我们需要用到UG或者其他的三维软件打开机器人3D模型查看旋转中心的坐标值,这里我们姑且用一个常量代替:(c2xc2yc2z),由于轴2的旋转轴不是y轴,因此不能直接套用绕y轴的旋转矩阵,但我们可以通过平移将其移动到与y轴重合的位置,然后再绕y轴旋转给定的关节角度,最后将其平移回原来的位置,这样可以通过3个变换操作得到轴2对应的旋转矩阵。

    首先将轴2平移使其与y轴重合,平移向量为(-c2x-c2y-c2z),对应的矩阵为:                                                       

    然后再绕y轴旋转给定的关节角度θ2,对应的矩阵为:             

    最后将其平移回原来的位置:

    因此最终轴2对应的旋转矩阵为上述3个矩阵的复合效果,即:

    注意这里是矩阵的左乘,从右往左读。

    轴3也是绕平行于y轴的轴线旋转,按照同样的方法,先平移,再旋转,最后再平移可以的得到轴3的旋转矩阵:

    轴4是绕平行于z轴的轴线旋转,按照上述方法可以得到轴4的旋转矩阵:

    轴5也是绕平行于y轴的轴线旋转:

    轴6是绕平行于z轴的轴线旋转:

     

    因此最终的所求的旋转矩阵为:

    在这里我们的机器人的初始姿态最好是零位状态,即每个关节角度为0的状态,方便我们分析问题,看看各个旋转轴是不是与坐标轴平行,如果不平行,此时还需要进行使旋转轴与某一选定坐标轴(x,y或z轴)对齐的旋转操作,再将此轴变回原来的位置。

     

    展开全文
  • 6自由度机器人运动学正反C++程序

    热门讨论 2015-07-26 21:14:10
    6自由度机器人运动学正、反C++程序,可直接运行,简单易懂!
  • Delta型并联机器人运动学正解 几何解法pdf,并联机器 人运 动学 的封闭 问题到 目前 为止没有得 到全面 解决, 常用 的解决方 案是采 用基于 代 数万 程组 的数值解法 , 该 方 法 不 足 之 处是推导过程复杂 , ...
  • puma机器人运动学正解

    2013-05-18 23:49:42
    本程序进行puma机器人运动学正解运算,通过给定各个关节角度数据,循环得出在不同关节角度下的机器人末端执行器位置,并且存储在数据文件中。本程序用MATLAB语句编写,并且通过仿真程序验证。
  • 本程序在MATLAB环境下编写PUMA机器人运动学正解算法,根据输入的机器人各关节角度得出机器人末端执行器的空间位姿,并且通过仿真验证。最终所有的关节角度数据和末端空间位姿均存储在相应的数据文件中,便于后续...
  • 6轴机器人运动学正解,逆1

    万次阅读 多人点赞 2017-12-14 21:27:35
    正解与逆的求解需要相应的机器人运动方程,其中关键的就是DH参数表 DH参数表用来描述机器人各关节坐标系之间的关系,有了DH参数表就可以在机器人各关节之间进行坐标转换 求解正解就是从关节1到关节5的坐标转换 ...

    正解
    给定机器人各关节的角度,计算出机器人末端的空间位置

    逆解
    已知机器人末端的位置和姿态,计算机器人各关节的角度值

    常见的工业机器人

    正解与逆解的求解需要相应的机器人运动方程,其中关键的就是DH参数表
    DH参数表用来描述机器人各关节坐标系之间的关系,有了DH参数表就可以在机器人各关节之间进行坐标转换
    求解正解就是从关节1到关节5的坐标转换
    基本知识
    关节:连接2个杆件的部分
    连杆长度 (a) :2个相邻关节轴线之间的距离
    连杆扭角 (alpha α) :2个相邻关节轴线之间的角度
    连杆偏距 (d) :2个关节坐标系的X轴之间的距离
    关节角度 (theta θ) :关节变量 计算时需要加初始角度偏移

    Z轴: 关节轴线
    X轴: 从Z(i)轴指向Z(i+1)轴 与a重合
    alpha: Z(i)轴绕X(i)轴旋转到Z(i+1)轴的角度
    a: 相邻的2个关节轴线之间的距离是a Z(i)轴到Z(i+1)轴
    d: 2个相邻的a之间的距离是d a(i-1)到a(i) 相邻X轴之间的距离

    关节角度 从Z轴正向看原点 逆时针旋转为正
    如果(a=0),X(i)与X(i-1)方向相同
    如果(a!=0),X(i)从Z(i)指向Z(i+1)

    图2

    图3
    机器人零点

    DH参数表

    关节 a d α
    1 100 0 90
    2 270 0 0
    3 60 0 90
    4 0 270 -90
    5 0 0 90
    6 0 0 0

    DH参数有多种表示方式,与坐标系及坐标轴的设定有关

    正解的计算方法
    机器人从关节1到关节6进行坐标变换,结果就是末端的位置坐标
    根据DH参数表以及关节变量的值,建立6个关节矩阵A1-A6,计算出转换矩阵T1-T6,T1-T6相乘得出结果
    6轴机器人4,5,6轴相交于1点 正解计算只算到第5轴
    为简化矩阵计算,关节1坐标系原点设在Z2轴的水平平面上,最终结果在Z方向需要再加上一个偏移值

    /* 4阶矩阵计算机器人正解 
     * 关节角度在文件 J1_J6中
     * 机器人参数在文件 param_table中
     * 坐标结果在屏幕输出 */
    
    #include <stdio.h>
    #include <math.h>
    #include <string.h>
    
    #define XYZ_F_J "./J1_J6"
    #define DESIGN_DT "./param_table"
    #define XYZ_F_TOOL "./tool_xyz"
    #define XYZ_F_WORLD "./world_xyz"
    
    
    #define RAD2ANG (3.1415926535898/180.0)
    #define IS_ZERO(var) if(var < 0.0000000001 && var > -0.0000000001){var = 0;} 
    
    #define MATRIX_1 1
    #define MATRIX_N 4
    
    #define DEF_TOOLXYZ 0  
        /* 0 没有工具坐标系 非零 有工具坐标系 */
    
    /*角度偏移*/
    #define ANGLE_OFFSET_J2 90
    #define ANGLE_OFFSET_J3 90
    //#define ANGLE_OFFSET_J4 -90
    
    typedef struct {
        double joint_v;  //joint variable
        double length;
        double d;
        double angle;
    }param_t;
    
    
        double matrix_A1[MATRIX_N][MATRIX_N];
        double matrix_A2[MATRIX_N][MATRIX_N];
        double matrix_A3[MATRIX_N][MATRIX_N];
        double matrix_A4[MATRIX_N][MATRIX_N];
        double matrix_A5[MATRIX_N][MATRIX_N];
        double matrix_A6[MATRIX_N][MATRIX_N];
    
    double matrix_worldxyz[MATRIX_N][MATRIX_N];
    double matrix_toolxyz[MATRIX_N][MATRIX_N];
    
    
    void initmatrix_A(param_t *p_table);
    void calculate_matrix_A(double matrix[MATRIX_N][MATRIX_N], param_t *p_param);
    
    int matrix_mul(double matrix_a[MATRIX_N][MATRIX_N],
                double matrix_b[MATRIX_N][MATRIX_N],
                double matrix_result[MATRIX_N][MATRIX_N]);
    
    int matrix_add(double matrix_a[MATRIX_N][MATRIX_N], 
                double matrix_b[MATRIX_N][MATRIX_N], 
                double matrix_sum[MATRIX_N][MATRIX_N], int m, int n);
    
    void matrix_copy(double matrix_a[MATRIX_N][MATRIX_N], 
                double matrix_b[MATRIX_N][MATRIX_N], int m, int n);
    
    void initmatrix_tool(double toolx, double tooly, double toolz);
    
    void printmatrix(double matrix[MATRIX_N][MATRIX_N], int m, int n)
    {
        int i, j;
    
        for(i=0; i<m; i++){
            for(j=0; j<n; j++){
                printf(" %lf ", matrix[i][j]);
            }
            printf("\n");
        }
        printf("\n");
    
    }
    
    void printmatrix_1(double matrix[MATRIX_N][1], int m, int n)
    {
        int i, j;
    
        for(i=0; i<m; i++){
            for(j=0; j<n; j++){
                printf(" %lf ", matrix[i][j]);
            }
            printf("\n");
        }
        printf("\n");
    
    }
    
    
    int main()
    {
    
        double matrix_T1[MATRIX_N][MATRIX_N];
        double matrix_T2[MATRIX_N][MATRIX_N];
        double matrix_T3[MATRIX_N][MATRIX_N];
        double matrix_T4[MATRIX_N][MATRIX_N];
        double matrix_T5[MATRIX_N][MATRIX_N];
        double matrix_T6[MATRIX_N][MATRIX_N];
    
        //double j1=0, j2=0, j3=0, j4=0, j5=0, j6=0;
        //double l1=0, l2=0, l3=0, d4=0, z_offset=0;
        double toolx=0, tooly=0, toolz=0, toolrx=0, toolry=0, toolrz=0;
        double worldx=0, worldy=0, worldz=0, worldrx=0, worldry=0, worldrz=0;
        double z_offset=0;
    
        param_t param_table[6] ={0};
        memset(param_table, 0, sizeof(param_table) );
    
        FILE * fp=NULL;
    
        fp=fopen(XYZ_F_J, "r");
        if(fp== NULL){
            perror("open J1_J6 file error\n");
            return 0;
        }
        fscanf(fp, "%lf%lf%lf%lf%lf%lf", 
                    &param_table[0].joint_v, 
                    &param_table[1].joint_v, 
                    &param_table[2].joint_v, 
                    &param_table[3].joint_v, 
                    &param_table[4].joint_v, 
                    &param_table[5].joint_v 
                    );
        printf("j1...j6\n%lf %lf %lf %lf %lf %lf\n",
                    param_table[0].joint_v, 
                    param_table[1].joint_v, 
                    param_table[2].joint_v, 
                    param_table[3].joint_v, 
                    param_table[4].joint_v, 
                    param_table[5].joint_v 
                    );
    
    
        //加初始角度偏移 j2 j3 
        param_table[1].joint_v += ANGLE_OFFSET_J2;
        param_table[2].joint_v += ANGLE_OFFSET_J3;
    
        //将机器人关节角度转换成弧度
        param_table[0].joint_v *= RAD2ANG;
        param_table[1].joint_v *= RAD2ANG;
        param_table[2].joint_v *= RAD2ANG;
        param_table[3].joint_v *= RAD2ANG;
        param_table[4].joint_v *= RAD2ANG;
        param_table[5].joint_v *= RAD2ANG;
    
        printf("\nj1...j6 RAD2ANG\n%lf %lf %lf %lf %lf %lf\n", 
                    param_table[0].joint_v, 
                    param_table[1].joint_v, 
                    param_table[2].joint_v, 
                    param_table[3].joint_v, 
                    param_table[4].joint_v, 
                    param_table[5].joint_v 
              );
    
        fclose(fp);
    
        fp=fopen(DESIGN_DT, "r");
        if( fp== NULL){
            perror("open param_table file error\n");
            return 0;
        }
    
    //读入关节参数
        int i;
        for(i=0; i<6; i++){
            fscanf(fp, "%lf%lf%lf", 
                        &param_table[i].length, 
                        &param_table[i].d, 
                        &param_table[i].angle );
        }
        fscanf(fp, "%lf", &z_offset );
        fclose(fp);
    
        param_table[0].angle *= RAD2ANG;
        param_table[1].angle *= RAD2ANG;
        param_table[2].angle *= RAD2ANG;
        param_table[3].angle *= RAD2ANG;
        param_table[4].angle *= RAD2ANG;
        param_table[5].angle *= RAD2ANG;
    
        initmatrix_A(param_table);
    /*
        //fscanf(fp, "%lf %lf %lf", &toolx, &tooly, &toolz);
        //printf("tool x y z\n%lf %lf %lf\n", toolx, tooly, toolz);
    
        fp=fopen(XYZ_F_TOOL, "r");
        if(fp== NULL || DEF_TOOLXYZ == 0){
            printf("no toolxyz \n");    
        }else{
            fscanf(fp, "%lf %lf %lf %lf %lf %lf", 
                        &toolx, &tooly, &toolz, &toolrx, &toolry, &toolrz);
            printf("\ntoolxyz\n%lf %lf %lf %lf %lf %lf\n", 
                        toolx, tooly, toolz, toolrx, toolry, toolrz);
            fclose(fp);
        }
        initmatrix_tool(toolx, tooly, toolz);
    */
    
        //计算变换矩阵 matrix T1---T6
        matrix_copy(matrix_A1, matrix_T1, MATRIX_N, MATRIX_N);
        printf("matrix_T1 =  \n");
        printmatrix(matrix_T1, MATRIX_N, MATRIX_N);
    
        matrix_mul(matrix_T1, matrix_A2, matrix_T2);
        printf("matrix_T2 =  \n");
        printmatrix(matrix_T2, MATRIX_N, MATRIX_N);
    
        matrix_mul(matrix_T2, matrix_A3, matrix_T3);
        printf("matrix_T3 =  \n");
        printmatrix(matrix_T3, MATRIX_N, MATRIX_N);
    
        matrix_mul(matrix_T3, matrix_A4, matrix_T4);
        printf("matrix_T4 =  \n");
        printmatrix(matrix_T4, MATRIX_N, MATRIX_N);
    
        matrix_mul(matrix_T4, matrix_A5, matrix_T5);
        printf("matrix_T5 =  \n");
        printmatrix(matrix_T5, MATRIX_N, MATRIX_N);
    
        matrix_mul(matrix_T5, matrix_A6, matrix_T6);
        printf("matrix_T6 =  \n");
        printmatrix(matrix_T6, MATRIX_N, MATRIX_N);
    
        //add();
        //matrix_worldxyz[2][0] +=z_offset;
    
        printf("\n----curent x, y, z-----\n%lf \n %lf\n %lf\n ", 
                    matrix_T6[0][3], matrix_T6[1][3], 
                    matrix_T6[2][3]+z_offset);
    
    
    }
    
    void initmatrix_A(param_t *p_table)
    {//计算关节坐标矩阵 matrix A1--A6
        calculate_matrix_A(matrix_A1, p_table+0);
        printf("matrix_A1 =  \n");
        printmatrix(matrix_A1, MATRIX_N, MATRIX_N);
    
        calculate_matrix_A(matrix_A2, p_table+1);
        printf("matrix_A2 =  \n");
        printmatrix(matrix_A2, MATRIX_N, MATRIX_N);
    
        calculate_matrix_A(matrix_A3, p_table+2);
        printf("matrix_A3 =  \n");
        printmatrix(matrix_A3, MATRIX_N, MATRIX_N);
    
        calculate_matrix_A(matrix_A4, p_table+3);
        printf("matrix_A4 =  \n");
        printmatrix(matrix_A4, MATRIX_N, MATRIX_N);
    
        calculate_matrix_A(matrix_A5, p_table+4);
        printf("matrix_A5 =  \n");
        printmatrix(matrix_A5, MATRIX_N, MATRIX_N);
    
        calculate_matrix_A(matrix_A6, p_table+5);
        printf("matrix_A6 =  \n");
        printmatrix(matrix_A6, MATRIX_N, MATRIX_N);
    }
    
    void calculate_matrix_A(double matrix[MATRIX_N][MATRIX_N], param_t *p_param)
    {//根据关节参数计算矩阵 
        double *pmatrix=(double *)matrix;
        double value, var_c, var_s, angle_c, angle_s;
    
        var_c = cos(p_param->joint_v);
        IS_ZERO(var_c);
        var_s = sin(p_param->joint_v);
        IS_ZERO(var_s);
        angle_c = cos(p_param->angle);
        IS_ZERO(angle_c);
        angle_s = sin(p_param->angle);
        IS_ZERO(angle_s);
    
        *pmatrix++ = var_c;
        //value = -var_s * angle_c;
        //IS_ZERO(value);
        *pmatrix++ = -var_s * angle_c;
        //value = var_s * angle_s;
        //IS_ZERO(value);
        *pmatrix++ = var_s * angle_s;
        //value = p_param->length * var_c;
        //IS_ZERO(value);
        *pmatrix++ = p_param->length * var_c;
    
        *pmatrix++ = var_s;
        //value = var_c * angle_c;
        //IS_ZERO(value);
        *pmatrix++ = var_c * angle_c;
        //value = -var_c *angle_s;
        //IS_ZERO(value);
        *pmatrix++ = -var_c *angle_s;
        //value = p_param->length * var_s;
        //IS_ZERO(value);
        *pmatrix++ = p_param->length * var_s;
    
        *pmatrix++ =0;
        *pmatrix++ = angle_s;
        *pmatrix++ = angle_c;
        *pmatrix++ = p_param->d;
    
        *pmatrix++ =0;
        *pmatrix++ =0;
        *pmatrix++ =0;
        *pmatrix =1;
    
    }
    
    void initmatrix_tool(double toolx, double tooly, double toolz)
    {
        if(DEF_TOOLXYZ == 0){
            matrix_toolxyz[2][0] =1;
        }else{
            matrix_toolxyz[0][0] =toolx;
            matrix_toolxyz[1][0] =tooly;
            matrix_toolxyz[2][0] =toolz;
    
            {/* 初始化 toolrx, tooly, toolz */}
        }
    
    }
    
    int matrix_mul(double matrix_a[MATRIX_N][MATRIX_N], 
                double matrix_b[MATRIX_N][MATRIX_N], 
                double matrix_result[MATRIX_N][MATRIX_N])
    {
        int i,j,k;
        double sum;
        double matrix_tmp[MATRIX_N][MATRIX_N]={0};
    
        /*嵌套循环计算结果矩阵(m*p)的每个元素*/
        for(i=0;i<MATRIX_N;i++)
          for(j=0;j<MATRIX_N;j++)
          {   
              /*按照矩阵乘法的规则计算结果矩阵的i*j元素*/
              sum=0;
              for(k=0;k<MATRIX_N;k++)
                sum += matrix_a[i][k] * matrix_b[k][j];
              matrix_tmp[i][j] = sum;
          }   
        matrix_copy(matrix_tmp, matrix_result, MATRIX_N, MATRIX_N);
        return 0;
    }
    
    int matrix_add(double matrix_a[MATRIX_N][MATRIX_N], 
                double matrix_b[MATRIX_N][MATRIX_N], 
                double matrix_sum[MATRIX_N][MATRIX_N], int m, int n)
    {
        int i,j;
        double matrix_tmp[MATRIX_N][MATRIX_N]={0};
    
        for(i=0; i<m; i++){
            for(j=0; j<n; j++){
                matrix_tmp[i][j] = matrix_a[i][j] + matrix_b[i][j];
            }
        }
        matrix_copy(matrix_tmp, matrix_sum, MATRIX_N, MATRIX_N);
    
        return 0;
    }
    
    
    void matrix_copy(double matrix_src[MATRIX_N][MATRIX_N], 
                double matrix_des[MATRIX_N][MATRIX_N], int m, int n)
    {
        int i,j;
        for(i=0; i<m; i++){
            for(j=0; j<n; j++){
                matrix_des[i][j] = matrix_src[i][j];
            }
        }
    }
    
    
    
    
    
    
    展开全文
  • 摘要:Calculation of the position and posture in robots is one among the basic elements in the study of robotic mechanisms. Many principles and methods of calculation have thus far appeared both ...

    摘要:

    Calculation of the position and posture in robots is one among the basic elements in the study of robotic mechanisms. Many principles and methods of calculation have thus far appeared both domestically and abroad,yet all shearing the common drawback of being too complicated. The authors have suggerted two methods, aimed at a simplification of the process. On its basis the authors seek to further simplify it, utilizing the concept of similar complex vector matrices and its special form —the based similar complex vector matrices, so that all the necessary calculations in robotic movements can be resolved with very simple mathematical manipulations.

    展开

    展开全文
  • 有关并联绳驱机器人运动学正解的学习Preface(complain)Perface(start)Advantages of parallel robotDisdvantages of parallel robotStructure establishmentInverse kinematics of parallel robot ...

    Preface(complain)

    个人学习总结,不喜勿喷(网图权侵删)

    活跃气氛
    这几周太忙太忙,上几周金工实习,每天没有时间搞事情,每周六日还要去学车占用了六日的学习时间(还好考完了(QAQ))。还在想竞赛如何进行主动示教(或许会更 )这周还来了一个电工电子认知实习(哭)。
    在没有时间的时间里,我试图通过熬夜(早上起不来 )来弥补坑,再加之被老师催了好几天所获得的动力

    以及掉了的头发!

    终于把并联机器人运动学正反解搞出来了,为什么网上关于绳驱的资料很少啊,我找了好久都没抄到现成的源码,还得自己编…
    (回归正题)
    试一试用英文写博客(感觉一下不一样的快感,折磨自己也折磨别人 )。

    大哥大姐求轻喷~~(不喷)~~ 写blog本就是一个在满足自己成就感的同时造福他人的过程,我明白写英文(绝对有语法和拼写错误!)肯定会让人感到有一点点的”不舒服“,但是总之凑合看吧,毕竟是一篇学习性质的blog,本人也是初学,还想练练英语(六级还没给过,哭了)。

    Perface(start)

    Parallel cable robot is a structure of closed loop kinematic chain,its moving platform has some independent kinematic chains attached to the base.
    It always is compiled with base frame,moving platform and some lines between us.

    并联机器人相对于串联机器人有很大的区别,它的区别在于它的关节居然并联在了一起,而不是像串糖葫芦一样串在一起的。
    由于这样的构型,她便拥有了与串联机器人不一样的优点和缺点:

    Advantages of parallel robot

    绳索牵引并联机器人采用绳索代替刚性连杆将末端执行器与静平台连接起来,使其具有工作空间大、负载质量比高、造价成本低和易于模块 化和维修等优点。他运动分析较容易、且可避免驱动轴之间的耦合(coupling) 效应。

    Disdvantages of parallel robot

    1.不易有动态误差,精度较高。

    2.运动惯性小。

    3.输出轴大部份承受轴向应力,机器刚性高,结构稳定。

    4.为热对称性结构设计,热变形量较小。

    5.在位置求解上,串联机构正解容易,反解困难,而并联机构正解困难,反解容易。

    6.工作空间较小。

    source:关注 | 并联式机构的优缺点与并联机构原理在机器人领域的应用
      
    由于上述种种原因,导致我们不能生搬硬拉,而是要在此系统基础上从新搞起来。

    在这里插入图片描述

    Forward kinematics solution:在并联机器人中,运动学正解是事先告诉你绳长数据(根数的绳长),让你通过这几根绳长的数据来计算出末端点为位姿,这不是一件简单的事情。

    Inverse kinematics solution:在并联机器人中,运动学逆解是事先告诉你动平台所在的位置和姿态后,让你求出四根绳长,这虽然不是啥容易事情但是却比运动学正解简单多了。(哭)

    Next we will use a simple but useful example to demostrate my Learning outcomes of parallel cable robot

    Structure establishment

    In this section,we will bulid a parallel robot by simple lines in a blank.p_1
    In this picture,you can see a black frame( robot body),four orange lines are stand for our cable,and the red square are moving platform,which make a ugly robot…
    In order to simplify the calculation,we set the body frame and moving frame’s base point is located at the central of body.(you can see that…)
    In fact,it is my personal point and I also don’t want to prove it.
    The x-axis, Y-axis and rotation angle have been marked on the drawing

    The parallel cable robot use its electric machineries to control its length of cables(orange line),which can control moving plateform to move.

    Setting
    Beacuse our robot’s body is changeless and our moving plate is a two dimensions.so we set the robot has 3 dofs :(X,Y,θ),It can move and rotate.

    Inverse kinematics of parallel robot

    while (1) wo shi cai ji wo shi cai ji end
    In my opinion,parallel robot’s Inverse kinematics is based on our moving platform’s position.our computer use our position to to calculate the length of four ropes.
    在这里插入图片描述
    SO WE MUST FIND OUT THE POSITION OF END EFFECTOR.

    follow path

    1. In order to control the robot to move a correct line we expect to and it also should meet our expectations——the position.

    2. hit him !Scatter all the positions until it turns to some correct points in every tiny time.

    3. put this data into the controller and we can control the electric machinery to rotate.

    4. complete.
      like this:
      在这里插入图片描述
      details:
      1.Determine the trajectory of the hinge point of the moving platform

      As we all know, the reason why the motion platform can move is not that it can move itself, but that the controller can adjust the four ropes Length to force it to move. And the hinge point of our rope is not on the real trajectory, but has a certain distance, so If we calculate the position of the hinge point, we can get the rope length at this time, and the motor can be controlled.

    2.These rope length data are arranged to obtain the trajectory of the overall motion platform.
    So we use this picture to show the process.
    在这里插入图片描述
    In this picture we depict a nomal position.our moving platform rotates a angle and move some…To express this positon we can use this equation.
    now_1 = TransM (旋转矩阵)* load_1 + P(位移向量);
    we can use a point(B1) to explain it:
    在这里插入图片描述
    The green square are our initial position,first,it will rotate a angle,then it turns the yellow square.It has completed the part of rotate(TransM (旋转矩阵)* load_1 ).Then we will move it(+ P(位移向量)😉
    The equation is completed.

    PS: we can imagine it as the position attitude of the platform by rotating and then offsetting, but it happens instantaneously.

    MATLAB for Inverse kinematics of parallel robot

    Its flow chart is:
    在这里插入图片描述
    The main codes are here

    while progress < target
        [progress, currentvel] = tcRunCycle(progress, reqvel, currentvel, cycle_time  , target  , maxaccel, feed_override, maxvel);         %调用速度规划函数
        time = time + cycle_time;                                                       %进行时间迭代
        
        x_now = progress / target * (x_1 - x_0) + x_0;                                 %计算当前位置
        y_now = progress / target * (y_1 - y_0) + y_0;
    
        Yaw_now_degree = (progress / target) * (Yaw_start - Yaw) + Yaw;              %计算当前角度
        
        P = [x_now;y_now;0];                                                       %动平台相对于静平台的实时位置
        
        TransM =[cosd(Yaw_now_degree),-sind(Yaw_now_degree),0;sind(Yaw_now_degree),cosd(Yaw_now_degree),0;0,0,1]
        %Z轴旋转矩阵
    
    load_1 = [ - 1; - 1;0];
        now_1 = TransM * load_1 + P;
        x_1_1 = now_1(1, 1);
        y_1_1 = now_1(2, 1);
    
    `` x1_run = linspace(x_1_1, L1_point_x, 1000);
        y1_run = linspace(y_1_1, L1_point_y, 1000);
        plot(x1_run, y1_run);
        hold on
    

    Then we can move it.

    Forward kinematics of parallel robot

    Forward kinematics of parallel robot is a difficult thing.As we all know,the fk has many solutions and needs to be solved iteratively. So we choose to use Newton-Raphson to solve it.
    (改成中文了(皮))
    首先我们需要定义我们的位置矢量P,也就是上面的now_1这样我们可以获得当前末端平台的位置。
    由于正运动学是已知绳索长度求解运动平台的位姿,所以我们在使用迭代时,四根绳长也会进行迭代,所以我们要进行绳长的计算:L=A-P(P:铰接点相对于坐标的向量,A:动平台中心点的位置。)叠一叠就出来了不行就继续叠。
    对于正运动学,自然要比逆运动学难,所以也不好搞,这里只说一下一种简单的正运动学求解方法,别的我还不会,没学

    1. 我们首先要把机器人建起来,包括动平台的大小,出绳点在何处。构建起来后,我们就可以进行下一步的操作了。
    load_1 = [-1;-1;0];                                         
    load_2 = [-1;1; 0];
    load_3 = [1;1;  0];
    load_4 = [1;-1; 0];
    
    L1_point_x = - 50;                                              
    L1_point_y = - 50;
    
    L2_point_x = - 50;                                              
    L2_point_y = 50;
    
    L3_point_x = 50;                                                
    L3_point_y = 50;
    
    L4_point_x = 50;                                                L4_point_y = - 50;
    

    可以自己设定哦…………
    3. 按照Newton-Raphson的方法,它需要一个初值要去逼近,这个值选的越好迭代越少越完美,但是靠人来估总觉不靠谱,这需要我后续学习如何机器给估值让他更加精确。

    x_now=1;                                                         
    y_now=1;
    z_now=0;
    Yaw_now_degree=0;
    
    1. 在这之后,我们还要来个绳长,因为正运动学是知道绳长求位姿,要是没绳长岂不是要坏菜。。。

    ps:当然,由于它是一个正运动学演示代码,要是可以你也可以把逆运动学的结果直接写个代码带到这里来,免除cv之苦………………

    l1_fk_find=91.107035936923570;                                  
    l2_fk_find=66.249280888240930;
    l3_fk_find=48.742662884505194;
    l4_fk_find=79.292950279803290;
    
    

    以上就是初始准备来,准备好我们就要开始迭代了!

    按照公式,我们一步一步做就完了,其实无脑写也是可以的,想要理解确实实属不易。
    它的原理其是就是一步一步逼近我们想要的结果,再把得到的结果与原来的对比,当小于我们设定的误差时就认为达到了我们所要完成的目标。
    代码放在了资源里,要的自取,等过一段时间我再理解理解再写,写到这里突然不会了,啊这。

    展开全文
  • 运动学正解分析是对并联机器人其它性能进行分析的基础,也是并联机器人研究中的一个难点。本文采用遗传算法来求解并联机器人的运动...实例表明该方法简单、方便、具有通用性,是求解并联机器人运动学问题的一种新策略。
  • 摘要:Calculation of the position and posture in robots is one among the basic elements in the study of robotic mechanisms. Many principles and methods of calculation have thus far appeared both ...
  • 对于并联机构的运动学分析,D-H参数法需要对每个连杆建立局部坐标系,通过各连杆的坐标转换来建立运动学方程,过程...最后应用该方法求解了典型Delta机器人运动学正解和工作空间,并进行了机器人样机的运动控制实验.
  • 6轴机器人运动学正解,逆2

    万次阅读 热门讨论 2017-12-15 17:37:04
    机器人学建模、规划与控制 西安交通大学出版社对于关节1,2,3可以从运动方程手工推导出各个关节旋转角度的计算公式 逆求解的结果并不是唯一的 可能有多组 /*计算逆 根据机器人坐标计算机器人关节角度 ...
  • Delta机构机器人算法资料 Delta机构机器人算法资料 Delta机构机器人算法资料
  • scara机器人运动学正

    千次阅读 多人点赞 2020-03-14 14:59:02
    文章目录一、scara机器人运动学正解二、scara机器人运动学1、正装scara机器人运动学2、吊装scara机器人运动学三、MATLAB代码 一、scara机器人运动学正解   末端BBB的xxx坐标为向量OA\bf{OA}OA与向量...
  • 机器人运动学

    千次阅读 2019-11-24 10:44:10
    机器人运动学 即根据工具坐标系相对于基坐标系的目标位姿,求解机器人各关节角。逆运动学在机器人学中占有非常重要的地位,是机器人轨迹规划和运动控制的基础,直接影响着控制的快速性与准确性。一般机器人运动...
  • 本文研究机器人运动学中的奇异点处理问题, 给出了机器人微分运动Jacobian矩阵J(q)条件数的一个上界, 并在此基础上提出机器人关节速度阻尼伪逆方法中阻尼系数的一种自适应调整方法, 该方法可以保证在奇异点附近...
  • Delta机器人运动学正反分析

    千次阅读 多人点赞 2020-06-28 11:41:22
    Delta机器人运动学正反分析 一、Delta机构简介 Delta机构是并联机构中的一种典型机构,起原始结构如图1所示。Delta机构由R.Clavel 博士在 1985年发明,是现在并联机器人中使用最多的一种,具备了并联机构所特有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,129
精华内容 2,451
关键字:

机器人运动学正解