精华内容
下载资源
问答
  • scara机器人雅克比矩阵

    千次阅读 2020-03-15 11:49:59
    文章目录一、scara机器人雅克比矩阵1、雅克比矩阵推导2、机器人末端速度与关节速度、末端加速度与关节加速度之间相互转换(1)、已知关节速度,计算末端速度(2)、已知关节加速度,计算末端加速度(3)、已知末端速度,...

    一、scara机器人雅克比矩阵

    1、雅克比矩阵推导

      scara机器人的运动学正解为:
    {x=L1cosθ1+L2cos(θ1+θ2)y=L1sinθ1+L2sin(θ1+θ2)z=θ3s2πc=θ1+θ2+θ4(1) \begin{cases} x=L_1cos\theta_1+L_2cos(\theta_1+\theta_2) \\ y=L_1sin\theta_1+L_2sin(\theta_1+\theta_2) \\ z=\frac{\theta_3s}{2\pi} \\ c=\theta_1+ \theta_2+ \theta_4 \tag 1 \end{cases}
      参考我另一篇博文:scara机器人运动学正逆解
      上式两边对时间tt求导,得:
    {vx=L1sinθ1θ1˙L2sin(θ1+θ2)(θ1˙+θ2˙)vy=L1cosθ1θ1˙+L2cos(θ1+θ2)(θ1˙+θ2˙)vz=θ3˙s2πvc=θ1˙+θ2˙+θ4˙(2) \begin{cases} v_x=-L_1sin\theta_1\dot{\theta_1}-L_2sin(\theta_1+\theta_2)(\dot{\theta_1} + \dot{\theta_2}) \\ v_y=L_1cos\theta_1\dot{\theta_1}+L_2cos(\theta_1+\theta_2) (\dot{\theta_1} + \dot{\theta_2}) \\ v_z=\frac{\dot{\theta_3}s}{2\pi} \\ v_c=\dot{\theta_1}+ \dot{\theta_2}+ \dot{\theta_4} \tag 2 \end{cases}
      上式写成矩阵形式,得:
    [vxvyvzvc]=J[θ1˙θ2˙θ3˙θ4˙](3) \left[ \begin{matrix} v_x \\ v_y \\ v_z \\ v_c \end{matrix} \right] = J \left[ \begin{matrix} \dot{\theta_1} \\ \dot{\theta_2} \\ \dot{\theta_3} \\ \dot{\theta_4} \end{matrix} \right] \tag{3}
      其中JJ为雅克比矩阵:
    J=[L1sinθ1L2sin(θ1+θ2)L2sin(θ1+θ2)00L1cosθ1+L2cos(θ1+θ2)L2cos(θ1+θ2)0000s/(2π)01101](4) J=\left[ \begin{matrix} -L_1sin\theta_1-L_2sin(\theta_1+\theta_2) & -L_2sin(\theta_1+\theta_2) & 0 & 0\\ L_1cos\theta_1+L_2cos(\theta_1+\theta_2) & L_2cos(\theta_1+\theta_2) & 0 & 0 \\ 0 & 0 & s/(2\pi) & 0 \\ 1 & 1 & 0 & 1 \end{matrix} \right] \tag{4}
      由式(3)可知,雅克比矩阵是机器人末端速度与关节速度的桥梁,是两者间的映射关系。雅克比矩阵的行列式为:
    J=L1sinθ1L2sin(θ1+θ2)L2sin(θ1+θ2)00L1cosθ1+L2cos(θ1+θ2)L2cos(θ1+θ2)0000s/(2π)01101=L1L2s2πsinθ2(5) \begin{aligned} |J|&=\left| \begin{matrix} -L_1sin\theta_1-L_2sin(\theta_1+\theta_2) & -L_2sin(\theta_1+\theta_2) & 0 & 0\\ L_1cos\theta_1+L_2cos(\theta_1+\theta_2) & L_2cos(\theta_1+\theta_2) & 0 & 0 \\ 0 & 0 & s/(2\pi) & 0 \\ 1 & 1 & 0 & 1 \end{matrix} \right| \\ &= \frac{L_1L_2s}{2\pi}sin{\theta_2} \\ \tag{5} \end{aligned}

      当sinθ2=0sin{\theta_2}=0时,J=0|J|=0,雅克比矩阵不可逆,此时机器人处于奇异位置。在奇异位置,无法通过机器人末端速度和雅克比矩阵计算得到机器人关节速度。或者说,在奇异位置,通过机器人末端速度和雅克比矩阵计算得到的机器人关节速度为无穷大,这在实际物理世界是不可能的。因此,机器人笛卡尔空间插补运动(直线、圆弧、样条插补等)一定要考虑并避开奇异位置。

    2、机器人末端速度与关节速度、末端加速度与关节加速度之间相互转换

    (1)、已知关节速度,计算末端速度

      已知机器人在工作空间内任意位置(即使是奇异位置,即sinθ2=0sin{\theta_2}=0)的关节位置和关节速度,通过雅克比矩阵,可以根据式(3)直接求得。

    (2)、已知关节加速度,计算末端加速度

      式(3)两边对时间t求导,得:
    [axayazac]=J˙[θ1˙θ2˙θ3˙θ4˙]+J[θ1¨θ2¨θ3¨θ4¨](6) \left[ \begin{matrix} a_x \\ a_y \\ a_z \\ a_c \end{matrix} \right] = \dot{J} \left[ \begin{matrix} \dot{\theta_1} \\ \dot{\theta_2} \\ \dot{\theta_3} \\ \dot{\theta_4} \end{matrix} \right] +J\left[ \begin{matrix} \ddot{\theta_1} \\ \ddot{\theta_2} \\ \ddot{\theta_3} \\ \ddot{\theta_4} \end{matrix} \right] \tag{6}
      其中:
    J˙=[L1cosθ1θ1˙L2cos(θ1+θ2)(θ1˙+θ2˙)L2cos(θ1+θ2)(θ1˙+θ2˙)00L1sinθ1θ1˙L2sin(θ1+θ2)(θ1˙+θ2˙)L2sin(θ1+θ2)(θ1˙+θ2˙)0000000000](7) \dot{J}=\left[ \begin{matrix} -L_1cos\theta_1\dot{\theta_1}-L_2cos(\theta_1+\theta_2) (\dot{\theta_1}+\dot{\theta_2}) & -L_2cos(\theta_1+\theta_2)(\dot{\theta_1}+\dot{\theta_2}) & 0 & 0\\ -L_1sin\theta_1\dot{\theta_1}-L_2sin(\theta_1+\theta_2)(\dot{\theta_1}+\dot{\theta_2}) & -L_2sin(\theta_1+\theta_2)(\dot{\theta_1}+\dot{\theta_2}) & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{matrix} \right] \tag{7}

    (3)、已知末端速度,计算关节速度

      当机器人不在奇异位置时,根据式(3),关节速度如下计算:
    [θ1˙θ2˙θ3˙θ4˙]=J1[vxvyvzvc](8) \left[ \begin{matrix} \dot{\theta_1} \\ \dot{\theta_2} \\ \dot{\theta_3} \\ \dot{\theta_4} \end{matrix} \right] = J^{-1}\left[ \begin{matrix} v_x \\ v_y \\ v_z \\ v_c \end{matrix} \right] \tag{8}
      由于3,4轴关节速度很容易根据式(2)单独求得:
    {θ3˙=2πvz/sθ4˙=vcθ1˙θ2˙(9) \begin{cases} \dot{\theta_3}=2\pi v_z / s \\ \dot{\theta_4}=v_c-\dot{\theta_1}- \dot{\theta_2} \\ \tag {9} \end{cases}
      只考虑1,2轴关节速度的计算显得更加简单,计算量也更小。令:
    {s1=sinθ1s12=sin(θ1+θ2)c1=cosθ1c12=cos(θ1+θ2)(10) \begin{cases} s_1=sin\theta_1 \\ s_{12}=sin(\theta_1+\theta_2) \\ c_1=cos\theta_1 \\ c_{12}=cos(\theta_1+\theta_2) \tag {10} \end{cases}

    {a12=L2s12a11=L1s1+a12b1=vxa22=L2c12a21=L1c1+a22b2=vy(11) \begin{cases} a_{12}=-L_2s_{12} \\ a_{11}=-L_1s_1+a_{12} \\ b_1=v_x \\ a_{22}=L_2c_{12} \\ a_{21}=L_1c_1+a_{22} \\ b_2=v_y \\ \tag {11} \end{cases}
      式(2)转化为关于θ1˙\dot{\theta_1}θ2˙\dot{\theta_2}的二元一次方程组:
    {a11θ1˙+a12θ2˙=b1a21θ1˙+a22θ2˙=b2(12) \begin{cases} a_{11}\dot{\theta_1}+a_{12}\dot{\theta_2}=b_1 \\ a_{21}\dot{\theta_1}+a_{22}\dot{\theta_2}=b_2 \\ \tag {12} \end{cases}

      上式解得:
    {θ1˙=(a12b2a22b1)/(a11a22a12a21)θ2˙=(a11b2a21b1)/(a11a22a12a21)(13) \begin{cases} \dot{\theta_1}=-(a_{12}b_2 - a_{22}b_1)/(a_{11}a_{22} - a_{12}a_{21}) \\ \dot{\theta_2}=(a_{11}b_2 - a_{21}b_1)/(a_{11}a_{22} - a_{12}a_{21}) \\ \tag {13} \end{cases}

    (4)、已知末端加速度,计算关节加速度

      当机器人不在奇异位置时,根据式(6),关节加速度如下计算:
    [θ1¨θ2¨θ3¨θ4¨]=J1([axayazac]J˙[θ1˙θ2˙θ3˙θ4˙])(14) \left[ \begin{matrix} \ddot{\theta_1} \\ \ddot{\theta_2} \\ \ddot{\theta_3} \\ \ddot{\theta_4} \end{matrix} \right]=J^{-1}\left( \left[ \begin{matrix} a_x \\ a_y \\ a_z \\ a_c \end{matrix} \right] -\dot{J} \left[ \begin{matrix} \dot{\theta_1} \\ \dot{\theta_2} \\ \dot{\theta_3} \\ \dot{\theta_4} \end{matrix} \right] \right) \tag{14}
      由于3,4轴关节加速度很容易根据式(9)单独求得:
    {θ3¨=2πaz/sθ4¨=acθ1¨θ2¨(15) \begin{cases} \ddot{\theta_3}=2\pi a_z / s \\ \ddot{\theta_4}=a_c-\ddot{\theta_1}- \ddot{\theta_2} \\ \tag {15} \end{cases}
      只考虑1,2轴关节加速度的计算显得更加简单,计算量也更小。式(2)两边对时间t求导,得:

    {ax=L1(cosθ1θ1˙2+sinθ1θ1¨)L2[cos(θ1+θ2)(θ1˙+θ2˙)2         +sin(θ1+θ2)(θ1¨+θ2¨)]ay=L1(sinθ1θ1˙2+cosθ1θ1¨)+L2[sin(θ1+θ2)(θ1˙+θ2˙)2         +cos(θ1+θ2)(θ1¨+θ2¨)](16) \begin{cases} a_x=-L_1(cos\theta_1\dot{\theta_1}^2 + sin\theta_1\ddot{\theta_1})-L_2[cos(\theta_1+\theta_2)(\dot{\theta_1} + \dot{\theta_2})^2 \\ \ \ \ \ \ \ \ \ \ + sin(\theta_1+\theta_2)(\ddot{\theta_1} + \ddot{\theta_2})] \\ a_y=L_1(-sin\theta_1\dot{\theta_1}^2+cos\theta_1\ddot{\theta_1})+L_2[-sin(\theta_1+\theta_2) (\dot{\theta_1} + \dot{\theta_2})^2 \\ \ \ \ \ \ \ \ \ \ +cos(\theta_1+\theta_2) (\ddot{\theta_1} + \ddot{\theta_2}) ]\\ \tag {16} \end{cases}
      令:
    {d1=ax+L1c1θ1˙2+L2c12(θ1˙+θ2˙)2d2=ay+L1s1θ1˙2+L2s12(θ1˙+θ2˙)2(17) \begin{cases} d_1=a_x+L_1c_1\dot{\theta_1}^2+L_2c_{12}(\dot{\theta_1} + \dot{\theta_2})^2 \\ d_2=a_y +L_1s_1\dot{\theta_1}^2+L_2s_{12}(\dot{\theta_1} + \dot{\theta_2})^2\\ \tag {17} \end{cases}

      式(16)转化为关于θ1¨\ddot{\theta_1}θ2¨\ddot{\theta_2}的二元一次方程组:
    {a11θ1¨+a12θ2¨=d1a21θ1¨+a22θ2¨=d2(18) \begin{cases} a_{11}\ddot{\theta_1}+a_{12}\ddot{\theta_2}=d_1 \\ a_{21}\ddot{\theta_1}+a_{22}\ddot{\theta_2}=d_2 \\ \tag {18} \end{cases}

      上式解得:
    {θ1¨=(a12d2a22d1)/(a11a22a12a21)θ2¨=(a11d2a21d1)/(a11a22a12a21)(19) \begin{cases} \ddot{\theta_1}=-(a_{12}d_2 - a_{22}d_1)/(a_{11}a_{22} - a_{12}a_{21}) \\ \ddot{\theta_2}=(a_{11}d_2 - a_{21}d_1)/(a_{11}a_{22} - a_{12}a_{21}) \\ \tag {19} \end{cases}

    二、雅克比矩阵验证

    1、点到点运动

      (1)在[π,π][-\pi, \pi]中随机生成4个关节角度,生成点到点运动起点与终点(模拟示教过程)
      (2)速度规划(详见另一篇博文:归一化5次多项式速度规划)
      (3)ptp插补得到关节位置、速度、加速度
      (4)运动学正解得到笛卡尔位置(x,y,z,c),并作差分运算,估计笛卡尔分轴速度、加速度
      (5)利用雅克比矩阵计算笛卡尔分轴速度、加速度
      (6)绘图比较(4)与(5)的差异,验证雅克比矩阵正确性

    2、直线运动

      (1)给定直线运动起点与终点,手系handcoor,标志位flagJ1和flagJ2(模拟示教过程)
      (2)速度规划(详见另一篇博文:归一化5次多项式速度规划)
      (3)直线插补得到笛卡尔位置、速度、加速度
      (4)运动学逆解得到关节位置,并作差分运算,估计关节速度、加速度
      (5)利用雅克比矩阵计算关节速度、加速度
      (6)绘图比较(4)与(5)的差异,验证雅克比矩阵正确性

    三、MATLAB代码

    %{
    Function: scara_forward_kinematics
    Description: scara机器人运动学正解
    Input: 大臂长L1(mm),小臂长L2(mm),丝杆螺距screw(mm),机器人关节位置jointPos(rad)
    Output: 机器人末端位置cartesianPos(mm或rad)
    Author: Marc Pony(marc_pony@163.com)
    %}
    function cartesianPos = scara_forward_kinematics(L1, L2, screw, jointPos)
    theta1 = jointPos(1);
    theta2 = jointPos(2);
    theta3 = jointPos(3);
    theta4 = jointPos(4);
    x = L1 * cos(theta1) + L2 * cos(theta1 + theta2);
    y = L1 * sin(theta1) + L2 * sin(theta1 + theta2);
    z = theta3 * screw / (2 * pi);
    c = theta1 + theta2 + theta4;
    cartesianPos = [x; y; z; c];
    end
    
    %{
    Function: scara_inverse_kinematics
    Description: scara机器人运动学逆解
    Input: 大臂长L1(mm),小臂长L2(mm),丝杆螺距screw(mm),机器人末端坐标cartesianPos(mm或rad)
           手系handcoor,标志位flagJ1与flagJ2
    Output: 机器人关节位置jointPos(rad)
    Author: Marc Pony(marc_pony@163.com)
    %}
    function jointPos = scara_inverse_kinematics(L1, L2, screw, cartesianPos, handcoor, flagJ1, flagJ2)
    x = cartesianPos(1);
    y = cartesianPos(2);
    z = cartesianPos(3);
    c = cartesianPos(4);
    jointPos = zeros(4, 1);
    
    calculateError = 1.0e-8;
    c2 = (x^2 + y^2 - L1^2 -L2^2) / (2.0 * L1 * L2);%若(x,y)在工作空间里,则c2必在[-1,1]里,但由于计算精度,c2的绝对值可能稍微大于1
    temp = 1.0 - c2^2;
    
    if temp < 0.0
        if temp > -calculateError
            temp = 0.0;
        else
            error('区域不可到达');
        end
    end
    if handcoor == 0    %left handcoor
        jointPos(2) = atan2(-sqrt(temp), c2);
    else                %right handcoor
        jointPos(2) = atan2(sqrt(temp), c2);
    end
    s2 = sin(jointPos(2));
    jointPos(1) = atan2(y, x) - atan2(L2 * s2, L1 + L2 * c2);
    jointPos(3) = 2.0 * pi * z / screw;
    
    if jointPos(1) <= -pi
        jointPos(1) = jointPos(1) + 2.0*pi;
    end
    if jointPos(1) >= pi
        jointPos(1) = jointPos(1) - 2.0*pi;
    end
    
    if flagJ1 == 1
        if jointPos(1) >= 0.0
            jointPos(1) = jointPos(1) - 2.0*pi;
        else
            jointPos(1) = jointPos(1) + 2.0*pi;
        end
    end
    
    if flagJ2 == 1
        if jointPos(2) >= 0.0
            jointPos(2) = jointPos(2) - 2.0*pi;
        else
            jointPos(2) = jointPos(2) + 2.0*pi;
        end
    end
    jointPos(4) = c - jointPos(1) - jointPos(2);
    end
    
    clc;
    clear;
    close all;
    syms L1 L2 theta1 theta2 s real
    syms dtheta1 dtheta2 dtheta3 dtheta4 ddtheta1 ddtheta2 ddtheta3 ddtheta4 real
    syms vx vy vz vc ax ay az ac real;
    
    J = [-L1*sin(theta1) - L2*sin(theta1 + theta2),  -L2*sin(theta1 + theta2), 0, 0
        L1*cos(theta1) + L2*cos(theta1 + theta2),  L2*cos(theta1 + theta2), 0, 0
        0, 0, s/(2*pi), 0
        1, 1, 0, 1];
    detJ = simplify(det(J))
    
    dJ = [-L1*cos(theta1)*dtheta1 - L2*cos(theta1 + theta2)*(dtheta1 + dtheta2), -L2*cos(theta1 + theta2)*(dtheta1 + dtheta2), 0, 0
        -L1*sin(theta1)*dtheta1 - L2*sin(theta1 + theta2)*(dtheta1 + dtheta2), -L2*sin(theta1 + theta2)*(dtheta1 + dtheta2), 0, 0
        0, 0, 0, 0
        0, 0, 0, 0];
    
    cartesianVel = simplify(J * [dtheta1; dtheta2; dtheta3; dtheta4])
    cartesianAcc = simplify(dJ * [dtheta1; dtheta2; dtheta3; dtheta4] + J * [ddtheta1; ddtheta2; ddtheta3; ddtheta4])
    jointVel = simplify(J \ [vx; vy; vz; vc])
    jointAcc = simplify(J \ ([ax; ay; az; ac] - dJ * jointVel))
    
    %% 输入参数
    len1 = 200; %mm
    len2 = 200; %mm
    screw = 20; %mm
    speedJ = 200; %°/s
    accJ = 1200; %°/s^2
    linearSpeed = 100; %mm/s
    linearAcc = 800;   %mm/s^2
    orientationSpeed = 200; %°/s
    orientationAcc = 600;   %°/s^2
    dt = 0.001; %s
    
    %% 点到点运动, 验证雅克比矩阵正确性
    %(1)在[-pi, pi]中随机生成4个关节角度,生成点到点运动起点与终点(模拟示教过程)
    %(2)速度规划
    %(3)ptp插补得到关节位置、速度、加速度
    %(4)运动学正解得到笛卡尔位置(x,y,z,c),并作差分运算,估计笛卡尔分轴速度、加速度
    %(5)利用雅克比矩阵计算笛卡尔分轴速度、加速度
    %(6)绘图比较(4)与(5)的差异,验证雅克比矩阵正确性
    theta = (-pi + 2.0*pi*rand(2, 4))*180.0/pi;
    L = max(abs(diff(theta)));
    T = max([1.875 * L / speedJ, sqrt(5.7735 * L / accJ)]);
    
    t = (0 : dt : T)';
    u = t / T;
    if abs(t(end) - T) > 1.0e-8
        t = [t; T];
        u = [u; 1];
    end
    u = t / T;
    s = 10*u.^3 - 15*u.^4 + 6*u.^5;
    ds = 30*u.^2 -60*u.^3 + 30*u.^4;
    dds = 60*u - 180*u.^2 + 120*u.^3;
    
    len = L * s;
    vel = (L / T) * ds;
    acc = (L / T^2) * dds;
    rate = diff(theta) / L;
    jointPos = zeros(length(t), 4);
    jointVel = zeros(length(t), 4);
    jointAcc = zeros(length(t), 4);
    cartesianPos = zeros(length(t), 4);
    cartesianVel = zeros(length(t), 4);
    cartesianAcc = zeros(length(t), 4);
    for i = 1 : length(t)
        jointPos(i, :) = (theta(1, :) + len(i) * rate)*pi/180.0;
        jointVel(i, :) = (vel(i) * rate)*pi/180.0;
        jointAcc(i, :) = (acc(i) * rate)*pi/180.0;
        cartesianPos(i, :) = scara_forward_kinematics(len1, len2, screw, jointPos(i, :));
        cartesianPos(i, 4) = cartesianPos(i, 4)*180.0/pi;
        
        theta1 = jointPos(i, 1);
        theta2 = jointPos(i, 2);
        J = [-len1*sin(theta1) - len2*sin(theta1 + theta2),  -len2*sin(theta1 + theta2), 0, 0
            len1*cos(theta1) + len2*cos(theta1 + theta2),  len2*cos(theta1 + theta2), 0, 0
            0, 0, screw/(2*pi), 0
            1, 1, 0, 1];
        
        dtheta1 = jointVel(i, 1);
        dtheta2 = jointVel(i, 2);
        dtheta3 = jointVel(i, 3);
        dtheta4 = jointVel(i, 4);
        ddtheta1 = jointAcc(i, 1);
        ddtheta2 = jointAcc(i, 2);
        ddtheta3 = jointAcc(i, 3);
        ddtheta4 = jointAcc(i, 4);
        
        dJ = [-len1*cos(theta1)*dtheta1 - len2*cos(theta1 + theta2)*(dtheta1 + dtheta2), -len2*cos(theta1 + theta2)*(dtheta1 + dtheta2), 0, 0
            -len1*sin(theta1)*dtheta1 - len2*sin(theta1 + theta2)*(dtheta1 + dtheta2), -len2*sin(theta1 + theta2)*(dtheta1 + dtheta2), 0, 0
            0, 0, 0, 0
            0, 0, 0, 0];
        
        cartesianVel(i, :) = (J * [dtheta1; dtheta2; dtheta3; dtheta4])';
        cartesianAcc(i, :) = (dJ * [dtheta1; dtheta2; dtheta3; dtheta4] + J * [ddtheta1; ddtheta2; ddtheta3; ddtheta4])';
        cartesianVel(i, 4) = cartesianVel(i, 4)*180.0/pi;
        cartesianAcc(i, 4) = cartesianAcc(i, 4)*180.0/pi;
    end
    cartesianVel2 = diff(cartesianPos) ./ diff(t);
    cartesianAcc2 = diff(cartesianVel2) ./ diff(t(2:end));
    
    figure(1)
    set(gcf, 'color','w');
    subplot(2,2,1)
    plot(t, cartesianVel(:, 1), '--r')
    hold on
    plot(t(2:end), cartesianVel2(:, 1), 'b')
    xlabel('t/s');
    ylabel('v_x/ mm/s');
    subplot(2,2,2)
    plot(t, cartesianVel(:, 2), '--r')
    hold on
    plot(t(2:end), cartesianVel2(:, 2), 'b')
    xlabel('t/s');
    ylabel('v_y/ mm/s');
    legend('通过雅克比矩阵换算','通过差分换算');
    subplot(2,2,3)
    plot(t, cartesianVel(:, 3), '--r')
    hold on
    plot(t(2:end), cartesianVel2(:, 3), 'b')
    xlabel('t/s');
    ylabel('v_z/ mm/s');
    subplot(2,2,4)
    plot(t, cartesianVel(:, 4), '--r')
    hold on
    plot(t(2:end), cartesianVel2(:, 4), 'b')
    xlabel('t/s');
    ylabel('v_c/ °/s');
    
    figure(2)
    set(gcf, 'color','w');
    subplot(2,2,1)
    plot(t, cartesianAcc(:, 1), '--r')
    hold on
    plot(t(3:end), cartesianAcc2(:, 1), 'b')
    xlabel('t/s');
    ylabel('a_x/ mm/s^2');
    subplot(2,2,2)
    plot(t, cartesianAcc(:, 2), '--r')
    hold on
    plot(t(3:end), cartesianAcc2(:, 2), 'b')
    xlabel('t/s');
    ylabel('a_y/ mm/s^2');
    legend('通过雅克比矩阵换算','通过差分换算');
    subplot(2,2,3)
    plot(t, cartesianAcc(:, 3), '--r')
    hold on
    plot(t(3:end), cartesianAcc2(:, 3), 'b')
    xlabel('t/s');
    ylabel('a_z/ mm/s^2');
    subplot(2,2,4)
    plot(t, cartesianAcc(:, 4), '--r')
    hold on
    plot(t(3:end), cartesianAcc2(:, 4), 'b')
    xlabel('t/s');
    ylabel('a_c/ °/s^2');
    
    %% 直线运动, 验证雅克比矩阵正确性
    %(1)给定直线运动起点与终点,手系handcoor,标志位flagJ1和flagJ2(模拟示教过程)
    %(2)速度规划
    %(3)直线插补得到笛卡尔位置、速度、加速度
    %(4)运动学逆解得到关节位置,并作差分运算,估计关节速度、加速度
    %(5)利用雅克比矩阵计算关节速度、加速度
    %(6)绘图比较(4)与(5)的差异,验证雅克比矩阵正确性
    handcoor = 0;
    flagJ1 = 0;
    flagJ2 = 0;
    pos = [200 100 0 60
        250 200 20 80]; %mm °
    x1 = pos(1, 1);
    y1 = pos(1, 2);
    z1 = pos(1, 3);
    cc1 = pos(1, 4);
    x2 = pos(2, 1);
    y2 = pos(2, 2);
    z2 = pos(2, 3);
    cc2 = pos(2, 4);
    
    L = sqrt((x2 - x1)^2 + (y2 - y1)^2 + (z2 - z1)^2);
    C = abs(cc2 - cc1);
    T = max([1.875 * L / linearSpeed, 1.875 * C / orientationSpeed, ...
        sqrt(5.7735 * L / linearAcc), sqrt(5.7735 * C / orientationAcc)]);
    
    t = (0 : dt : T)';
    u = t / T;
    if abs(t(end) - T) > 1.0e-8
        t = [t; T];
        u = [u; 1];
    end
    u = t / T;
    s = 10*u.^3 - 15*u.^4 + 6*u.^5;
    ds = 30*u.^2 -60*u.^3 + 30*u.^4;
    dds = 60*u - 180*u.^2 + 120*u.^3;
    
    len = L * s;
    vel = (L / T) * ds;
    acc = (L / T^2) * dds;
    cartesianPos = zeros(length(t), 4);
    cartesianVel = zeros(length(t), 4);
    cartesianAcc = zeros(length(t), 4);
    jointPos = zeros(length(t), 4);
    jointVel = zeros(length(t), 4);
    jointAcc = zeros(length(t), 4);
    rate = [x2 - x1, y2 - y1, z2 - z1, cc2 - cc1] / L;
    for i = 1 : length(t)
        
        cartesianPos(i, :) = [x1, y1, z1, cc1] + len(i) * rate;
        cartesianVel(i, :) = vel(i) * rate;
        cartesianAcc(i, :) = acc(i) * rate;
        
        cartesianPos(i, 4) = cartesianPos(i, 4)*pi/180.0;
        jointPos(i, :) = scara_inverse_kinematics(len1, len2, screw, cartesianPos(i, :), handcoor, flagJ1, flagJ2);
        
        theta1 = jointPos(i, 1);
        theta2 = jointPos(i, 2);
        s1 = sin(theta1);
        s12 = sin(theta1 + theta2);
        c1 = cos(theta1);
        c12 = cos(theta1 + theta2);
        
        vx = cartesianVel(i, 1);
        vy = cartesianVel(i, 2);
        vz = cartesianVel(i, 3);
        vc = cartesianVel(i, 4)*pi/180.0;
        
        a12 = -len2*s12;
        a11 = -len1*s1 + a12;
        b1 = vx;
        a22 = len2*c12;
        a21 = len1*c1 + a22;
        b2 = vy;
        temp = a11*a22 - a12*a21;
        
        dtheta1 = -(a12*b2 - a22*b1)/temp;
        dtheta2 = (a11*b2 - a21*b1)/temp;
        dtheta3 = 2*pi*vz/screw;
        dtheta4 = vc - dtheta1 - dtheta2;
        jointVel(i, :) = [dtheta1, dtheta2, dtheta3, dtheta4];
        
        ax = cartesianAcc(i, 1);
        ay = cartesianAcc(i, 2);
        az = cartesianAcc(i, 3);
        ac = cartesianAcc(i, 4)*pi/180.0;
        
        d1 = ax + len1*c1*dtheta1^2 + len2*c12*(dtheta1 + dtheta2)^2;
        d2 = ay + len1*s1*dtheta1^2 + len2*s12*(dtheta1 + dtheta2)^2;
        ddtheta1 = -(a12*d2 - a22*d1)/temp;
        ddtheta2 = (a11*d2 - a21*d1)/temp;
        ddtheta3 = 2*pi*az/screw;
        ddtheta4 = ac - ddtheta1 - ddtheta2;
        
        jointAcc(i, :) = [ddtheta1, ddtheta2, ddtheta3, ddtheta4];
    end
    jointVel2 = diff(jointPos) ./ diff(t);
    jointAcc2 = diff(jointVel2) ./ diff(t(2:end));
    
    figure(3)
    set(gcf, 'color','w');
    subplot(2,2,1)
    plot(t, jointVel(:, 1)*180.0/pi, '--r')
    hold on
    plot(t(2:end), jointVel2(:, 1)*180.0/pi, 'b')
    xlabel('t/s');
    ylabel('vj1/ °/s');
    subplot(2,2,2)
    plot(t, jointVel(:, 2)*180.0/pi, '--r')
    hold on
    plot(t(2:end), jointVel2(:, 2)*180.0/pi, 'b')
    xlabel('t/s');
    ylabel('vj2/ °/s');
    legend('通过雅克比矩阵换算','通过差分换算');
    subplot(2,2,3)
    plot(t, jointVel(:, 3)*180.0/pi, '--r')
    hold on
    plot(t(2:end), jointVel2(:, 3)*180.0/pi, 'b')
    xlabel('t/s');
    ylabel('vj3/ °/s');
    subplot(2,2,4)
    plot(t, jointVel(:, 4)*180.0/pi, '--r')
    hold on
    plot(t(2:end), jointVel2(:, 4)*180.0/pi, 'b')
    xlabel('t/s');
    ylabel('vj4/ °/s');
    
    figure(4)
    set(gcf, 'color','w');
    subplot(2,2,1)
    plot(t, jointAcc(:, 1), '--r')
    hold on
    plot(t(3:end), jointAcc2(:, 1), 'b')
    xlabel('t/s');
    ylabel('aj1/ °/s^2');
    subplot(2,2,2)
    plot(t, jointAcc(:, 2), '--r')
    hold on
    plot(t(3:end), jointAcc2(:, 2), 'b')
    xlabel('t/s');
    ylabel('aj2/ °/s^2');
    legend('通过雅克比矩阵换算','通过差分换算');
    subplot(2,2,3)
    plot(t, jointAcc(:, 3), '--r')
    hold on
    plot(t(3:end), jointAcc2(:, 3), 'b')
    xlabel('t/s');
    ylabel('aj3/ °/s^2');
    subplot(2,2,4)
    plot(t, jointAcc(:, 4), '--r')
    hold on
    plot(t(3:end), jointAcc2(:, 4), 'b')
    xlabel('t/s');
    ylabel('aj4/ °/s^2');
    

    1
    2
    3
    4

    展开全文
  • 利用matlab机器人工具包求解机器人雅克比矩阵

    千次阅读 热门讨论 2018-04-16 21:49:49
    利用matlab机器人工具包可以简化编程,方便的进行机器人有关参数的计算,如...6自由度机器人雅克比矩阵求解程序如下,首先根据D-H参数定义连杆,再生成机器人,最后完成雅克比矩阵计算。 L1 = Link('d', 0.68, '...

    利用matlab机器人工具包可以简化编程,方便的进行机器人有关参数的计算,如雅克比矩阵的计算。

    最新版机器人工具包为mltbx格式,可以直接拖进maltab进行安装,安装成功后在matlab中运行rvc_startup,打开机器人工具包。

    6自由度机器人雅克比矩阵求解程序如下,首先根据D-H参数定义连杆,再生成机器人,最后完成雅克比矩阵计算。

            L1 = Link('d', 0.68, 'a', 0.2, 'alpha', -pi/2);
            L2 = Link('d', 0, 'a', 0.089, 'alpha', 0);
            L3 = Link('d', 0, 'a', 0.150, 'alpha', -pi/2);
            L4 = Link('d', 0.88, 'a', 0, 'alpha', -pi/2);
            L5 = Link('d', 0, 'a', 0, 'alpha', pi/2);
            L6 = Link('d', 0.3, 'a', 0, 'alpha', 0);
            bot = SerialLink([L1 L2 L3 L4 L5 L6],'name','50kg','offset',[0 -pi/2 0 0 -pi/2 0]);%Á¬½ÓÁ¬¸Ë
            syms a1;
            syms a2;
            syms a3;
            syms a4;
            syms a5;
            syms a6;
            IK=[a1,a2,a3,a4,a5,a6];
            J=bot.jacob0(IK);
            j=char(vpa(J))

    计算结果为6×6的矩阵,可以显示在txt文档中。



    展开全文
  • 使用matlab建立机器人雅克比矩阵

    千次阅读 多人点赞 2018-08-25 13:01:33
    雅克比矩阵为m*n矩阵,其中m表示末端操作空间的自由度,一般为6个(即 x y z Wx Wy Wz),n为关节空间的关节数,本例中为6旋转关节机器人,史陶比尔TX90 雅克比矩阵中各个元素的推导如图 通过编写代码和机器人...

    雅克比矩阵是联系末端操作空间速度与空间关节速度的枢扭,推导过程如下:
    这里写图片描述
    雅克比矩阵为m*n矩阵,其中m表示末端操作空间的自由度,一般为6个(即 x y z Wx Wy Wz),n为关节空间的关节数,本例中为6旋转关节机器人,史陶比尔TX90
    雅克比矩阵中各个元素的推导如图
    这里写图片描述

    通过编写代码和机器人工具箱求解对比,发现结果一致,运行结果如下:

    >> >> [J,T] = TX90_jacobian([0 0 0 0 0  0 ])//机器人工具箱的解
    
    J =
    
      -50.0000  950.0000  525.0000         0  100.0000         0
       50.0000    0.0000         0         0         0         0
             0   -0.0000         0         0         0         0
             0         0         0         0         0         0
             0    1.0000    1.0000         0    1.0000         0
        1.0000    0.0000    0.0000    1.0000    0.0000    1.0000
    
    
    T =
    
        1.0000         0         0   50.0000
             0    1.0000         0   50.0000
             0         0    1.0000  950.0000
             0         0         0    1.0000
    
    >>  >> [ J ] = ykb( [0 0 0 0 0 0 ] )//自己写的求雅克比函数
    
    J =
    
    [ -50.0,        950.0,        525.0,   0,        100.0,   0]
    [  50.0,            0,            0,   0,            0,   0]
    [     0,            0,            0,   0,            0,   0]
    [     0,            0,            0,   0,            0,   0]
    [     0,          1.0,          1.0,   0,          1.0,   0]
    [   1.0, 6.123234e-17, 6.123234e-17, 1.0, 6.123234e-17, 1.0]
    
    >>>> [ T06  ] = tx90_ForwardKinematics( [0 0 0 0 0 0] )
    
    T06 =
    
         1     0     0    50
         0     1     0    50
         0     0     1   950
         0     0     0     1
     %自己的正运动学变换矩阵和雅克比矩阵与机器人工具箱求解的一致  
     %工具箱输入角度为[90 45 0 90 0 45]的求解结果 
    
    >> [J,T] = TX90_jacobian([90 45 0 90 0 45])
    
    J =
    
     -721.7514         0         0         0 -100.0000         0
      -50.0000  671.7514  371.2311   -0.0000         0         0
       -0.0000 -671.7514 -371.2311    0.0000   -0.0000         0
        0.0000   -1.0000   -1.0000    0.0000   -0.0000    0.0000
       -0.0000    0.0000    0.0000    0.7071   -0.7071    0.7071
        1.0000   -0.0000   -0.0000    0.7071    0.7071    0.7071
    
    
    T =
    
       -0.7071    0.7071    0.0000  -50.0000
       -0.5000   -0.5000    0.7071  721.7514
        0.5000    0.5000    0.7071  671.7514
             0         0         0    1.0000
    
     % 自己创建的函数输入角度为[90 45 0 90 0 45]的求解结果     
    >> [ J ] = ykb( [90 45 0 90 0 45] )
    
    J =
    
    [ -721.75144, -4.1132913e-14, -2.2731346e-14,              0,         -100.0,              0]
    [      -50.0,      671.75144,      371.23106,              0, -4.3297803e-15,              0]
    [          0,     -671.75144,     -371.23106,              0,  1.7934537e-15,              0]
    [          0,           -1.0,           -1.0, -1.7934537e-17,  4.3297803e-17, -1.7934537e-17]
    [          0,              0,              0,     0.70710678,    -0.70710678,     0.70710678]
    [        1.0,   6.123234e-17,   6.123234e-17,     0.70710678,     0.70710678,     0.70710678]
    
    > [ T06  ] = tx90_ForwardKinematics( [90 45 0 90 0 45] )
    
    T06 =
    
       -0.7071    0.7071         0  -50.0000
       -0.5000   -0.5000    0.7071  721.7514
        0.5000    0.5000    0.7071  671.7514
             0         0         0    1.0000
    
    

    以上代码表明该雅克比矩阵建立方法与机器人工具箱函数算出的结果一致,
    运行速度方面,机器人工具箱函数更快
    以下为代码:

    % 机器人工具箱的函数
    function [J,T] = TX90_jacobian(theta)
    %UNTITLED 此处显示有关此函数的摘要
    %   此处显示详细说明
    %syms q1 q2 q3 q4 q5 q6
    q1 = theta(1)/180*pi;
    q2 = theta(2)/180*pi-pi/2;
    q3 = theta(3)/180*pi+pi/2;
    q4 = theta(4)/180*pi;
    q5 = theta(5)/180*pi;
    q6 = theta(6)/180*pi;
    %             theta  d   a  alpha
    L(1) = Link([q1,  0,  50,  -pi/2]);
    L(2) = Link([q2,  0,  425,    0]);
    L(3) = Link([q3,  50,  0,   pi/2]);
    L(4) = Link([q4, 425, 0,  -pi/2]);
    L(5) = Link([q5,  0,   0,  pi/2]);
    L(6) = Link([q6, 100 ,0,     0]);
    tx90 = SerialLink(L, 'name', '史陶比尔TX90');
    J = tx90.jacob0([q1 q2 q3 q4 q5 q6]);
    T = tx90.fkine([q1 q2 q3 q4 q5 q6]);
    
    end
    
    %自写函数
    function [ T ] = Trans( alpha, a, theta, d ) % 变换矩阵
    T =[ 
            cos(theta), -sin(theta)*cos(alpha), sin(theta)*sin(alpha), a*cos(theta);
            sin(theta), cos(theta)*cos(alpha), -cos(theta)*sin(alpha), a*sin(theta);
                  0,          sin(alpha),              cos(alpha),            d;
                  0,              0,                        0,                  1];
    end
    
    
    function [ JT ] = test( theta )
    %UNTITLED 此处显示有关此函数的摘要
    %   此处显示详细说明
    T01 =Trans( -pi/2, 50, theta(1), 0 );%[alpha a theta d ]  长度统一为mm单位,角度统一为度单位
    T12 =Trans( 0, 425, theta(2)-pi/2, 0 );
    T23 =Trans( pi/2, 0, theta(3)+pi/2, 50 );
    T34 =Trans( -pi/2, 0, theta(4), 425 );
    T45 =Trans( pi/2, 0, theta(5), 0 );
    T56 =Trans( 0, 0, theta(6), 100 );
    T02 = T01*T12;
    T03 = T01*T12*T23;
    T04 = T01*T12*T23*T34;
    T05  =T01*T12*T23*T34*T45;
    T06=T01*T12*T23*T34*T45*T56;
    
    T00 = [1 0 0 0;0 1 0 0; 0 0 1 0; 0  0 0 1]; %因为这是标准dh参数建立的转换,设工具坐标系与T06重合,与教程中改进的DH参数确定角速度方法不同
    
    ox = T06(1,4); oy = T06(2,4);oz = T06(3,4);
    w1 = T00(1:3,3);w2 = T01(1:3,3);w3 = T02(1:3,3);w4 = T03(1:3,3);w5 = T04(1:3,3);w6 = T05(1:3,3);
    %Jw = [w1,w2,w3,w4,w5,w6];
    J11 = diff(ox,theta(1));J12 = diff(ox,theta(2));J13 = diff(ox,theta(3));J14 = diff(ox,theta(4));J15 = diff(ox,theta(5));J16 = diff(ox,theta(6));
    J21 = diff(oy,theta(1));J22 = diff(oy,theta(2));J23 = diff(oy,theta(3));J24 = diff(oy,theta(4));J25 = diff(oy,theta(5));J26 = diff(oy,theta(6));
    J31 = diff(oz,theta(1));J32 = diff(oz,theta(2));J33 = diff(oz,theta(3));J34 = diff(oz,theta(4));J35 = diff(oz,theta(5));J36 = diff(oz,theta(6));
    
    JT = [J11,J12,J13,J14,J15,J16;
          J21,J22,J23,J24,J25,J26;
          J31,J32,J33,J34,J35,J36;
           w1, w2, w3, w4, w5, w6];
    
    end
    
    
    function [ J ] = ykb( jiao )
    %UNTITLED 此处显示有关此函数的摘要
    %   此处显示详细说明
    syms a1 a2 a3 a4 a5 a6;
    theta =[a1 a2 a3 a4 a5 a6];
    JT =test( theta );
    q = jiao*pi/180;
    
    JT1=subs(JT,a1,q(1));JT2=subs(JT1,a2,q(2));JT3=subs(JT2,a3,q(3));JT4=subs(JT3,a4,q(4));JT5=subs(JT4,a5,q(5));J=subs(JT5,a6,q(6));
    
    old = digits;
    digits(4)
    J = vpa(J,8);
    
    end
    
    function [ T06  ] = tx90_ForwardKinematics( theta )
    if nargin<2; end  
    d6=100;
    
    T1 =Trans( -90, 50, theta(1), 0 );%[alpha a theta d ]  
    T2 =Trans( 0, 425, theta(2)-90, 0 );
    T3 =Trans( 90, 0, theta(3)+90, 50 );
    T4 =Trans( -90, 0, theta(4), 425 );
    T5 =Trans( 90, 0, theta(5), 0 );
    T6 =Trans( 0, 0, theta(6), d6 );
    T06=T1*T2*T3*T4*T5*T6;
    
    
    
    end
    
    function [ T ] = Trans( alpha, a, theta, d ) 
    T =[ 
            cosd(theta), -sind(theta)*cosd(alpha), sind(theta)*sind(alpha), a*cosd(theta);
            sind(theta), cosd(theta)*cosd(alpha), -cosd(theta)*sind(alpha), a*sind(theta);
                  0,          sind(alpha),              cosd(alpha),            d;
                  0,              0,                        0,                  1];
    end
    

    总结:
    通过编写机器人雅克比矩阵函数,对matlab的掌握更进一步,使用函数时,必须在文件夹里打开,否则容易报错,掌握如何对符号函数进行化简,求偏导最后再代值运算,比较实用。
    参考教程:http://mp.weixin.qq.com/s?__biz=MzI1MTA3MjA2Nw==&mid=400013659&idx=1&sn=68abc24fff30e4a16601316a0fe91a46&chksm=7bdb82774cac0b61e3f6cbfd3bfa92973e9c033c816912b5c7439f880254a8571f66897e9229&mpshare=1&scene=23&srcid=0824XXjKUPzVQ1UjlVkokGjl#rd

    展开全文
  • 机器人雅克比矩阵计算

    千次阅读 2016-10-11 12:36:00
    雅克比矩阵机器人关节空间的速度映射到笛卡尔空间的末端速度。  从上图可以看出,只考虑关节y的旋转(假定其它关节固定不动,在某一时刻关节y变化一个微小的角度ϕ--注意联系偏微分的定义),则末端将绕着y...

      雅克比矩阵将机器人关节空间的速度映射到笛卡尔空间的末端速度。

     

      从上图可以看出,只考虑关节y的旋转(假定其它关节固定不动,在某一时刻关节y变化一个微小的角度ϕ--注意联系偏微分的定义),则末端将绕着y以||sx− sy||为半径旋转,末端速度为:ϕwy × (sx− sy),则可以推出雅克比矩阵J中关于关节y的那一列为:∂sx /∂θy=wy × (sx− sy)

      We want to find a way to change the joint angles so as to move the links’ positions closer to the desired positions. This process can be iterated in such a way that each iteration moves the links’ positions closer to their target positions until eventually new joint positions are reached that place the links close enough to their desired positions. The reason for using an iterative procedure is that it is usually too complicated to actually solve for joint angles,θ , in terms of the desired link positions. The iterative procedure will be easier to implement and, if it converges sufficiently well, can provide values for the joint angles that put the links arbitrarily close to their desired positions. For a single step of the iterative procedure, we consider the function telling us how links’ positions depend on joint angles. We then evaluate the partial derivatives of this function to find a linear approximation to the function. That is, we compute the rates of changes in links’ positions with respect to the rates of changes in joint angles. These give a Jacobian matrix of partial derivatives. With some assumptions about the nonsingularity of the Jacobian matrix, we can then find a way to change the joints’ angles so as to move the links’ positions closer to the desired positions. Since the Jacobian gives only a linear approximation to the function, we have to iterate the process until it converges to a good solution.

      The first step in setting up the inverse kinematics problem is to define the Jacobian matrix, which will tell us how the position of x changes with respect to small changes in the angles θ; in other words, the matrix will contain the partial derivatives of sx withrespect to the variables θ .

      If the joint y is translational, the entry in the Jacobian matrix is even easier to compute. Suppose the joint performs translation the direction of the unit vector wy , so that the the joint “angle” measures distance moved in the direction wy. Then if the end effector is affected by the joint, we have sx /∂θy=wy 。即如果该关节为移动关节,则雅克比矩阵中这一列为移动副的方向向量wy

      To see that this correctly defines the partial derivative, note the following: (a) If x is not a proper descendant of y, then the rotation of y’s joint does not affect the position of x,and so ∂sx /∂θy = 0. (b) Otherwise, the vector from point y to point x is equal to sxsy,and the rotation axis for angle θy is the axis wy. An infinitesimal rotation ϕ radians around the axis wy centered at sy will move the point x an infinitesimal distance given by the vector ϕwy × (sx− sy). From this observation, the second part of the definition of ∂sx /∂θy is obtained immediately. Figure XII.7 shows how to visualize the derivation of the formula for the partial derivative.

      即如果末端x不受关节y的影响,如情形(a) ;或者关节y正位于机器人末端,则∂sx /∂θy = 0。 sy为关节y的位置向量,wy为单位向量,其指向沿着关节的轴线方向,in this case, if angles are measured in radians with the direction of rotation given by the right rule and if the end effector is affected by the joint, then the corresponding entry in the Jacobian is wy × (sx− sy)

     

     

    参考:

    1. 3-D Computer Graphics: A Mathematical Introduction with OpenGL, Cambridge University Press, 2003    Ch. 12

    2. John J.Craig.  Introduction to Robotics Mechanics and Control

    转载于:https://www.cnblogs.com/21207-iHome/p/5948659.html

    展开全文
  • 机器人的两个雅可比矩阵 ------前面的机械手基础(1)-(3),我们分别讲了机械手的相机模型,机械手的正逆运动学分析,机械手的基于位置和基于图像的视觉伺服控制方法。 ------在这三个部分,我们似乎知道了的主要...
  • 机器人雅克比矩阵

    千次阅读 2016-04-21 23:37:21
    机器人雅克比矩阵 以平面二自由度机器人为例子: from: http://blog.sina.com.cn/u/2707887295
  • 机器人基础之雅克比矩阵概述雅克比矩阵的构造微分运动和广义速度微分变换法MATLAB实现 概述 雅克比矩阵J(q)J(q)J(q)是从关节空间向操作空间的速度传递的线性关系,借助于机械原理中的概念,可以理解为广义传动比。 ...
  • 疑问:比如说雅克比矩阵J为6x2矩阵,任务维度也是2,那么要如何求逆呢 是不是也可以用广义逆的方法 如果雅克比矩阵J为6x4矩阵,但是一个对象在空间中是6个自由度,这又要怎么处理  1.非冗余机器人 雅克比矩阵的...
  • 13. 机器人正运动学---雅克比矩阵(1)

    千次阅读 2020-09-20 10:57:02
    这篇文章主要介绍机器人雅克比矩阵的由来以及利用几何法求解雅克比矩阵
  • 前言上一篇文章我们从几何意义的角度出发介绍了雅克比...这篇文章数学公式较多,如果你刚开始了解机器人雅克比矩阵可以暂时跳过,老实说这篇文章是偏理论的,只是为了加深对矩阵求导以及雅克比矩阵的理解,实际应...
  • 0、四自由机械臂系统模型如下 (1)定义几何参数 syms L1Y_s L2Y_s L3Y_s syms theta1 syms theta2 syms theta3 syms theta4 alpha = theta1 + theta2; beta = theta1 + theta2 + ... 然后,我们将这些坐
  • 雅克比矩阵的求法 1.传统的连杆传递求法 2.利用变换矩阵T求法 04T = [ 04R 04P;0 0 0 1] 04v = 04P’ 注意这里P对角度求导,结果要带上Θ 44v = 40R*04v 根据 44v 求解 4J 例子 连杆传递的求法: 变换矩阵的求...
  • 机器人基础--雅克比矩阵

    千次阅读 2019-10-01 22:30:21
    雅克比矩阵的理论部分 机器人逆运动学 材料来源于:https://www.cnblogs.com/21207-iHome/p/5948659.html 引用请备注上材料的来源者:https://www.cnblogs.com/21207-iHome/p/5948659.html 机器人运动学公式 参考...
  • puma560机器人的正逆解求解以及雅克比矩阵和动力学
  • 雅克比矩阵机器人

    千次阅读 2015-03-23 09:32:02
    转自:http://weibo.com/p/230418a16714bf0102vafv?from=page_100505_profile&wvr=6&mod=wenzhangmod 机器人雅克比矩阵 以平面二自由度机器人为例子:
  • 说到机器人,肯定离不开一个矩阵,那就是雅克比矩阵
  • 雅克比矩阵 瞬态运动学 正运动学的齐次变换矩阵T,是从关节的Θ\ThetaΘ推知末端执行器的笛卡尔坐标 雅克比矩阵0v=0J(Θ)Θ˙^0v=^0J(\Theta)\dot{\Theta}0v=0J(Θ)Θ˙,是从关节的Θ˙\dot\ThetaΘ˙速度推知末端...
  • 机器人微分运动—雅克比矩阵

    千次阅读 2019-05-07 09:45:21
    https://blog.csdn.net/qq_22820121/article/details/81296986
  • 雅克比矩阵还是先了解一下雅克比矩阵的由来吧。我们在高数中都学过函数以及函数的导数,设有一个关于时间的函数,那么它的时间导数为,这个很简单吧。现在我们换一个提法,在时间处对应的函数值是,当时间t在基础上...
  • 这篇文章主要介绍雅克比矩阵伪逆计算
  • 机器人机器人实验实机器人实验机器人机器人实验验验
  • 机器人的几何雅克比矩阵
  • J0:假设位姿q(1xN)对应的雅克比矩阵(6xN),N为机器人关节的个数,机器人雅克比矩阵将关节速度与末端执行器空间速度V=J0*qd映射到世界坐标系中,即在末端执行器坐标系中计算雅可比矩阵并将其转换为世界坐标系 ...
  • 这篇文章主要介绍通过正运动求导的方式导出雅克比矩阵的方法

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

机器人雅克比矩阵