rigidBodyJoint

Crear una articulación

Descripción

Los objetos rigidBodyJoint definen cómo se mueve un cuerpo rígido en relación con un punto de acoplamiento. En un robot con estructura de árbol, una articulación siempre pertenece a un cuerpo rígido específico y cada cuerpo rígido tiene una articulación.

El objeto rigidBodyJoint puede describir articulaciones de varios tipos. Al construir una estructura de árbol de cuerpo rígido con rigidBodyTree, debe asignar el objeto Joint a un cuerpo rígido usando la clase rigidBody.

Los distintos tipos de articulaciones admitidas son:

• fixed: articulación fija que impide el movimiento relativo entre dos cuerpos.

• revolute: articulación de un solo grado de libertad (DOF) que gira alrededor de un eje determinado. También denominada articulación de pasador o de bisagra.

• prismatic: articulación de un solo grado de libertad (DOF) que se desliza a lo largo de un eje determinado. También denominada articulación deslizante.

• floating: articulación de seis DOF que permite cualquier traslación y rotación.

Cada tipo de articulación tiene diferentes propiedades con diferentes dimensiones, en función de su geometría definida.

Creación

Sintaxis

jointObj = rigidBodyJoint(jname)

jointObj = rigidBodyJoint(jname,jtype)

Descripción

jointObj = rigidBodyJoint(jname) crea una articulación fija con el nombre especificado.

jointObj = rigidBodyJoint(jname,jtype) crea una articulación del tipo especificado con el nombre especificado.

Argumentos de entrada

jname — Nombre de la articulación

escalar de cadena | vector de caracteres

Nombre de la articulación, especificado como un vector de caracteres o un escalar de cadena. El nombre de la articulación debe ser único para acceder a ella desde fuera del árbol de cuerpo rígido.

Ejemplo: "elbow_right"

Tipos de datos: char | string

jtype — Tipo de articulación

"fixed" (predeterminado) | escalar de cadena | vector de caracteres

Tipo de articulación, especificado como un vector de caracteres o un escalar de cadena. El tipo de articulación predefine determinadas propiedades al crear la articulación.

Los distintos tipos de articulaciones admitidas son:

• "fixed": articulación fija que impide el movimiento relativo entre dos cuerpos.

• "revolute": articulación de un solo grado de libertad (DOF) que gira alrededor de un eje determinado. También denominada articulación de pasador o de bisagra.

• "prismatic": articulación de un solo grado de libertad (DOF) que se desliza a lo largo de un eje determinado. También denominada articulación deslizante.

• "floating": articulación de seis DOF que permite traslación y rotación libres.

Ejemplo: "prismatic"

Tipos de datos: char | string

Propiedades

Type — Tipo de articulación

"fixed" (predeterminado) | escalar de cadena | vector de caracteres

Esta propiedad o parámetro es de solo lectura.

Tipo de articulación, devuelto como un vector de caracteres o un escalar de cadena. El tipo de articulación predefine determinadas propiedades al crear la articulación.

Los distintos tipos de articulaciones admitidas son:

• "fixed": articulación fija que impide el movimiento relativo entre dos cuerpos.

• "revolute": articulación de un solo grado de libertad (DOF) que gira alrededor de un eje determinado. También denominada articulación de pasador o de bisagra.

• "prismatic": articulación de un solo grado de libertad (DOF) que se desliza a lo largo de un eje determinado. También denominada articulación deslizante.

• "floating": articulación de seis DOF que permite traslación y rotación libres.

Si el cuerpo rígido que contiene esta articulación se añade a un modelo de robot, el tipo de articulación debe modificarse reemplazando la articulación usando replaceJoint.

Ejemplo: "prismatic"

Tipos de datos: char | string

Name — Nombre de la articulación

escalar de cadena | vector de caracteres

Nombre de la articulación, devuelto como un vector de caracteres o un escalar de cadena. El nombre de la articulación debe ser único para acceder a ella desde fuera del árbol de cuerpo rígido. Si el cuerpo rígido que contiene esta articulación se añade a un modelo de robot, el nombre de la articulación debe modificarse reemplazando la articulación usando replaceJoint.

Ejemplo: "elbow_right"

Tipos de datos: char | string

PositionLimits — Límites de posición de la articulación

vector fila de dos elementos | matriz de 7 por 2

Límites de posición de la articulación, especificados como un vector fila de dos elementos de valores [min max] o como una matriz de 7 por 2 de valores [min max] dependiendo del tipo de articulación:

• fixed: [NaN NaN] (predeterminado). Una articulación fija no tiene límites de articulación. Los cuerpos permanecen fijos entre sí.

• revolute: [-pi pi] (predeterminado). Los límites definen el ángulo de rotación alrededor del eje en radianes.

• prismatic: [-0.5 0.5] (predeterminado). Los límites definen el movimiento lineal a lo largo del eje en metros.

• "floating": [NaN(4,2); repmat([-5 5],3,1)] (predeterminado). La rotación, representada como cuaternión, no tiene límites de articulación. Cada fila de los límites de posición define el movimiento lineal a lo largo de los ejes x, y y z, respectivamente.

Ejemplo: [-pi/2 pi/2]

HomePosition — Posición inicial de la articulación

escalar | vector fila de siete elementos

Posición inicial de la articulación, especificada como un escalar o un vector fila de siete elementos dependiendo del tipo de articulación. La posición inicial debe estar dentro del rango establecido por PositionLimits. La función homeConfiguration utiliza esta propiedad para generar la configuración inicial predefinida para un árbol de cuerpo rígido completo.

En función del tipo de articulación, la posición inicial tiene una definición diferente.

• fixed: 0 (predeterminado). Una articulación fija no tiene una posición inicial relevante.

• revolute: 0 (predeterminado). Una articulación rotativa tiene una posición inicial definida por el ángulo de rotación alrededor del eje de la articulación en radianes.

• prismatic: 0 (predeterminado). Una articulación prismática tiene una posición inicial definida por el movimiento lineal a lo largo del eje de la articulación en metros.

• floating: [1 0 0 0 0 0 0] (predeterminado). Una articulación flotante tiene una posición inicial definida por un cuaternión de identidad y una posición xyz.

Ejemplo: pi/2 radianes para una articulación revolute

JointAxis — Eje de movimiento de la articulación

[NaN NaN NaN] (predeterminado) | vector unitario de tres elementos

Eje de movimiento de la articulación, especificado como un vector unitario de tres elementos. El vector puede tener cualquier dirección en el espacio 3D en coordenadas locales.

En función del tipo de articulación, el eje de la articulación tiene una definición diferente.

• fixed: una articulación fija no tiene un eje de movimiento relevante.

• revolute: una articulación rotativa hace girar el cuerpo en el plano perpendicular al eje de la articulación.

• prismatic: una articulación prismática mueve el cuerpo en un movimiento lineal a lo largo de la dirección del eje de la articulación.

• floating: una articulación flotante hace girar el cuerpo libremente en el espacio. No es posible establecer la propiedad JointAxis para la articulación flotante.

Ejemplo: [1 0 0] para el movimiento alrededor del eje x de una articulación revolute

JointToParentTransform — Transformación fija del marco de articulación al marco principal

eye(4) (predeterminado) | matriz de transformación homogénea de 4 por 4

Esta propiedad o parámetro es de solo lectura.

Transformación fija del marco de articulación al marco principal, devuelta como una matriz de transformación homogénea de 4 por 4. La transformación convierte las coordenadas de los puntos en el marco de la articulación predecesor a la estructura del cuerpo principal.

Ejemplo: eye(4)

ChildToJointTransform — Transformación fija dla estructura del cuerpo secundario al marco de la articulación

eye(4) (predeterminado) | matriz de transformación homogénea de 4 por 4

Esta propiedad o parámetro es de solo lectura.

Transformación fija dla estructura del cuerpo secundario al marco de la articulación, devuelta como una matriz de transformación homogénea de 4 por 4. La transformación convierte las coordenadas de los puntos en la estructura del cuerpo secundario en el marco de la articulación sucesor.

Ejemplo: eye(4)

Funciones del objeto

copy	Create copy of joint
setFixedTransform	Establezca las propiedades de transformada fija de una articulación

Ejemplos

Acoplar un cuerpo rígido y una articulación a un árbol de cuerpo rígido

Añada un cuerpo rígido y la correspondiente articulación a un árbol de cuerpo rígido. Cada objeto rigidBody contiene un objeto rigidBodyJoint y debe añadirse a rigidBodyTree mediante addBody.

Cree un árbol de cuerpo rígido.

rbtree = rigidBodyTree;

Cree un cuerpo rígido con un nombre único.

body1 = rigidBody('b1');

Cree una articulación rotativa. De forma predeterminada, el objeto rigidBody tiene una articulación fija. Sustituya la articulación asignando un objeto rigidBodyJoint nuevo a la propiedad body1.Joint.

jnt1 = rigidBodyJoint('jnt1','revolute');
body1.Joint = jnt1;

Añada el cuerpo rígido al árbol. Especifique el nombre del cuerpo al que está acoplando el cuerpo rígido. Como se trata del primer cuerpo, utilice el nombre base del árbol.

basename = rbtree.BaseName;
addBody(rbtree,body1,basename)

Utilice showdetails en el árbol para confirmar que el cuerpo rígido y la articulación se han añadido correctamente.

showdetails(rbtree)

--------------------
Robot: (1 bodies)

 Idx    Body Name   Joint Name   Joint Type    Parent Name(Idx)   Children Name(s)
 ---    ---------   ----------   ----------    ----------------   ----------------
   1           b1         jnt1     revolute             base(0)   
--------------------

Construir un manipulador robótico utilizando parámetros Denavit-Hartenberg

Utilice los parámetros Denavit-Hartenberg (DH) del robot Puma560® para construir un robot. Los cuerpos rígidos se añaden de uno en uno con la transformación de elemento primario en secundario especificada por el objeto de articulación.

Los parámetros DH definen la geometría del robot en términos de cómo se acopla cada cuerpo rígido a su elemento principal. Para mayor facilidad, configure los parámetros del robot Puma560 en una matriz[1]. El robot Puma es un manipulador de cadena en serie. Los parámetros DH son relativos a la fila anterior de la matriz, correspondiente al acoplamiento de la articulación anterior.

dhparams = [0   	pi/2	0   	0;
            0.4318	0       0       0
            0.0203	-pi/2	0.15005	0;
            0   	pi/2	0.4318	0;
            0       -pi/2	0   	0;
            0       0       0       0];

Cree un objeto de árbol de cuerpo rígido para construir el robot.

robot = rigidBodyTree;

Cree el primer cuerpo rígido y añádalo al robot. Para añadir un cuerpo rígido:

1. Cree un objeto rigidBody y asígnele un nombre único.

2. Cree un objeto rigidBodyJoint y asígnele un nombre único.

3. Utilice setFixedTransform para especificar la transformación de cuerpo a cuerpo con parámetros DH. El último elemento de los parámetros DH, theta, se ignora porque el ángulo depende de la posición de articulación.

4. Llame a addBody para acoplar la primera articulación del cuerpo al marco base del robot.

body1 = rigidBody('body1');
jnt1 = rigidBodyJoint('jnt1','revolute');

setFixedTransform(jnt1,dhparams(1,:),'dh');
body1.Joint = jnt1;

addBody(robot,body1,'base')

Cree y añada otros cuerpos rígidos al robot. Especifique el nombre del cuerpo anterior llamando a addBody para acoplarlo. Cada transformada fijada es relativa al marco de coordenadas de la articulación anterior.

body2 = rigidBody('body2');
jnt2 = rigidBodyJoint('jnt2','revolute');
body3 = rigidBody('body3');
jnt3 = rigidBodyJoint('jnt3','revolute');
body4 = rigidBody('body4');
jnt4 = rigidBodyJoint('jnt4','revolute');
body5 = rigidBody('body5');
jnt5 = rigidBodyJoint('jnt5','revolute');
body6 = rigidBody('body6');
jnt6 = rigidBodyJoint('jnt6','revolute');

setFixedTransform(jnt2,dhparams(2,:),'dh');
setFixedTransform(jnt3,dhparams(3,:),'dh');
setFixedTransform(jnt4,dhparams(4,:),'dh');
setFixedTransform(jnt5,dhparams(5,:),'dh');
setFixedTransform(jnt6,dhparams(6,:),'dh');

body2.Joint = jnt2;
body3.Joint = jnt3;
body4.Joint = jnt4;
body5.Joint = jnt5;
body6.Joint = jnt6;

addBody(robot,body2,'body1')
addBody(robot,body3,'body2')
addBody(robot,body4,'body3')
addBody(robot,body5,'body4')
addBody(robot,body6,'body5')

Verifique que el robot se ha construido correctamente con la función showdetails o show. showdetails enumera todos los cuerpos en la ventana de comandos de MATLAB®. show muestra el robot con una determinada configuración (de forma predeterminada, la inicial). Las llamadas a axis modifican los límites de eje y ocultan las etiquetas de eje.

showdetails(robot)

--------------------
Robot: (6 bodies)

 Idx    Body Name   Joint Name   Joint Type    Parent Name(Idx)   Children Name(s)
 ---    ---------   ----------   ----------    ----------------   ----------------
   1        body1         jnt1     revolute             base(0)   body2(2)  
   2        body2         jnt2     revolute            body1(1)   body3(3)  
   3        body3         jnt3     revolute            body2(2)   body4(4)  
   4        body4         jnt4     revolute            body3(3)   body5(5)  
   5        body5         jnt5     revolute            body4(4)   body6(6)  
   6        body6         jnt6     revolute            body5(5)   
--------------------

show(robot);
axis([-0.5,0.5,-0.5,0.5,-0.5,0.5])
axis off

Referencias

[1] Corke, P. I. y B. Armstrong-Helouvry. “A Search for Consensus among Model Parameters Reported for the PUMA 560 Robot”. Proceedings of the 1994 IEEE International Conference on Robotics and Automation, IEEE Computer. Soc. Press, 1994, págs. 1608–13. DOI.org (Crossref), doi:10.1109/ROBOT.1994.351360.

Modificar un modelo de árbol de cuerpo rígido

Realice cambios en un objeto rigidBodyTree existente. Puede obtener articulaciones, cuerpos y subárboles de reemplazo en el árbol de cuerpo rígido.

Cargue un manipulador ABB IRB-120T de Robotics System Toolbox™ loadrobot. Está especificado como un objeto rigidBodyTree.

manipulator = loadrobot("abbIrb120T");

Visualice el robot with show y lea los detalles del robot con showdetails.

show(manipulator);

showdetails(manipulator)

--------------------
Robot: (8 bodies)

 Idx     Body Name            Joint Name            Joint Type     Parent Name(Idx)   Children Name(s)
 ---     ---------            ----------            ----------     ----------------   ----------------
   1          base        base_link-base                 fixed         base_link(0)   
   2        link_1               joint_1              revolute         base_link(0)   link_2(3)  
   3        link_2               joint_2              revolute            link_1(2)   link_3(4)  
   4        link_3               joint_3              revolute            link_2(3)   link_4(5)  
   5        link_4               joint_4              revolute            link_3(4)   link_5(6)  
   6        link_5               joint_5              revolute            link_4(5)   link_6(7)  
   7        link_6               joint_6              revolute            link_5(6)   tool0(8)  
   8         tool0          joint6-tool0                 fixed            link_6(7)   
--------------------

Obtenga un cuerpo específico para inspeccionar las propiedades. El único elemento secundario del cuerpo link_3 es el cuerpo link_4. También puede copiar un cuerpo específico.

body3 = getBody(manipulator,"link_3");
childBody = body3.Children{1}

childBody = 
  rigidBody with properties:

            Name: 'link_4'
           Joint: [1x1 rigidBodyJoint]
            Mass: 1.3280
    CenterOfMass: [0.2247 1.5000e-04 4.1000e-04]
         Inertia: [0.0028 0.0711 0.0723 1.3052e-05 -1.3878e-04 -6.6037e-05]
          Parent: [1x1 rigidBody]
        Children: {[1x1 rigidBody]}
         Visuals: {'Mesh Filename link_4.stl'}
      Collisions: {'Mesh Filename link_4.stl'}

body3Copy = copy(body3);

Reemplace la articulación en el cuerpo link_3. Debe crear un objeto Joint nuevo y utilizar replaceJoint para asegurar que la geometría en la parte posterior del cuerpo no resulte afectada. Llame a setFixedTransform si es necesario para definir una transformada entre los cuerpos en lugar de utilizar las matrices de identificación predeterminadas.

newJoint = rigidBodyJoint("prismatic");
replaceJoint(manipulator,"link_3",newJoint);

showdetails(manipulator)

--------------------
Robot: (8 bodies)

 Idx     Body Name            Joint Name            Joint Type     Parent Name(Idx)   Children Name(s)
 ---     ---------            ----------            ----------     ----------------   ----------------
   1          base        base_link-base                 fixed         base_link(0)   
   2        link_1               joint_1              revolute         base_link(0)   link_2(3)  
   3        link_2               joint_2              revolute            link_1(2)   link_3(4)  
   4        link_3             prismatic                 fixed            link_2(3)   link_4(5)  
   5        link_4               joint_4              revolute            link_3(4)   link_5(6)  
   6        link_5               joint_5              revolute            link_4(5)   link_6(7)  
   7        link_6               joint_6              revolute            link_5(6)   tool0(8)  
   8         tool0          joint6-tool0                 fixed            link_6(7)   
--------------------

Elimine un cuerpo entero y obtenga el subárbol resultante con removeBody. El cuerpo eliminado se incluye en el subárbol.

subtree = removeBody(manipulator,"link_4")

subtree = 
  rigidBodyTree with properties:

     NumBodies: 4
        Bodies: {[1x1 rigidBody]  [1x1 rigidBody]  [1x1 rigidBody]  [1x1 rigidBody]}
          Base: [1x1 rigidBody]
     BodyNames: {'link_4'  'link_5'  'link_6'  'tool0'}
      BaseName: 'link_3'
       Gravity: [0 0 0]
    DataFormat: 'struct'

show(subtree);

Elimine el cuerpo link_3 modificado. Añada el cuerpo link_3 copiado original al cuerpo link_2, seguido del subárbol devuelto. El modelo de robot sigue siendo el mismo. Consulte la comparación detallada mediante showdetails.

removeBody(manipulator,"link_3");
addBody(manipulator,body3Copy,"link_2")
addSubtree(manipulator,"link_3",subtree)

showdetails(manipulator)

--------------------
Robot: (8 bodies)

 Idx     Body Name            Joint Name            Joint Type     Parent Name(Idx)   Children Name(s)
 ---     ---------            ----------            ----------     ----------------   ----------------
   1          base        base_link-base                 fixed         base_link(0)   
   2        link_1               joint_1              revolute         base_link(0)   link_2(3)  
   3        link_2               joint_2              revolute            link_1(2)   link_3(4)  
   4        link_3               joint_3              revolute            link_2(3)   link_4(5)  
   5        link_4               joint_4              revolute            link_3(4)   link_5(6)  
   6        link_5               joint_5              revolute            link_4(5)   link_6(7)  
   7        link_6               joint_6              revolute            link_5(6)   tool0(8)  
   8         tool0          joint6-tool0                 fixed            link_6(7)   
--------------------

Modelar un robot de base flotante con una articulación flotante

Este ejemplo muestra cómo modelar un robot flotante como un árbol de cuerpo rígido usando una articulación flotante, representada por una rigidBodyJoint de tipo "floating" en la base fija. Use este enfoque para la mayoría de las aplicaciones, como cinemática directa y dinámica. No obstante, si necesita usar solvers de cinemática inversa o modelos de movimiento para un robot con una base flotante, no puede utilizar la articulación "floating". Para modelar un robot de base flotante para cinemática inversa o modelos de movimiento, consulte Inverse Kinematics for Robots with Floating Base.

Primero, cree una base fija como árbol de cuerpo rígido vacío. Luego, cree un cuerpo rígido y añada una articulación de cuerpo rígido de tipo "floating" al cuerpo rígido.

rbt = rigidBodyTree(DataFormat="row");
floatingBaseBody = rigidBody("floatingBase");
floatingBaseBody.Joint = rigidBodyJoint("j1","floating");

Añada el cuerpo correcto al árbol de cuerpo rígido de base fija. Ahora el cuerpo rígido y la base fija se unen en la articulación flotante, lo que permite traslación y rotación libres en los ejes xyz y a lo largo de ellos.

addBody(rbt,floatingBaseBody,rbt.BaseName);

Cargue el modelo de árbol de cuerpo rígido del brazo robótico ABB IRB 120 y añada el árbol de cuerpo rígido cargado al árbol de cuerpo rígido de base flotante. Cambie el nombre de la propiedad BaseName del árbol de cuerpo rígido de base flotante a 'world' para evitar discrepancias con los nombres. Esta discrepancia con los nombres se debe a que ambos árboles de cuerpo rígido usan el nombre base predeterminado 'base_link'.

abbirb = loadrobot("abbIrb120",DataFormat="row");
rbt.BaseName = 'world';
addSubtree(rbt,"floatingBase",abbirb,ReplaceBase=false);

Para demostrar que el árbol de cuerpo rígido puede trasladarse y girar libremente en el espacio, visualice la base del brazo robótico en la coordenada xyz [-1.1, 0.2, 0.3] con una orientación de [0 pi/2 pi/3] en el marco de base fija.

baseOrientation = eul2quat([0 pi/3 pi/3]); % ZYX Euler rotation order
basePosition = [-1.1 0.2 0.3];
floatingRBTConfig = [baseOrientation,basePosition,homeConfiguration(abbirb)]

floatingRBTConfig = 1×13

    0.7500    0.4330    0.4330   -0.2500   -1.1000    0.2000    0.3000         0         0         0         0         0         0

show(rbt,floatingRBTConfig);
axis equal
title(["Robot Joint Configuration With Base", "at Desired Position and Orientation"])

Ahora puede usar este robot de base flotante para aplicaciones de cinemática directa y dinámica. Como se ha mencionado anteriormente, no es posible modelar un robot de base flotante de este modo si tiene planea usar inverseKinematics o realizar planificación de movimiento. Si lo intenta, se generará un error de función de cinemática inversa. Para modelar un robot flotante para cinemática inversa y planificación de movimiento, consulte Inverse Kinematics for Robots with Floating Base.

Limitaciones

• Estos objetos y funciones no admiten árboles de cuerpo rígido que contienen articulaciones "floating":

  • manipulatorCHOMP

  • inverseKinematics

  • analyticalInverseKinematics

  • generalizedInverseKinematics

  • taskSpaceMotionModel

  • jointSpaceMotionModel

• Estos bloques no admiten árboles de cuerpo rígido que contienen articulaciones "floating":

  • Joint Space Motion Model

  • Task Space Motion Model

  • Inverse Kinematics

• Inverse Kinematics Designer no admite árboles de cuerpo rígido que contienen articulaciones "floating".

• Simscape™ Multibody™ no admite la importación de árboles de cuerpo rígido que contienen articulaciones flotantes.

Para obtener más información acerca de estas limitaciones y cómo modelar un robot de base flotante para su uso con estos objetos, funciones y bloques, consulte Inverse Kinematics for Robots with Floating Base.

Referencias

[1] Craig, John J. Introduction to Robotics: Mechanics and Control. Reading, MA: Addison-Wesley, 1989.

[2] Siciliano, Bruno. Robotics: Modelling, Planning and Control. London: Springer, 2009.

Capacidades ampliadas

Generación de código C/C++
Genere código C y C++ mediante MATLAB® Coder™.

Historial de versiones

Introducido en R2016b

R2024a: Soporte de articulación flotante

El objeto rigidBodyJoint ahora admite el tipo de articulación flotante. Esto permite modelar robots con bases flotantes para dinámica, cinemática directa y planificación de movimiento.

R2019b: Se ha modificado el nombre de rigidBodyJoint

Se ha modificado el nombre del objeto robotics.Joint; el nuevo nombre es rigidBodyJoint. Utilice rigidBodyJoint para crear todos los objetos.

Consulte también

rigidBody | rigidBodyTree

Temas

• Construir un robot paso a paso
• Modelo de robot de árbol de cuerpo rígido