La traducción de esta página aún no se ha actualizado a la versión más reciente. Haga clic aquí para ver la última versión en inglés.

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.

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.

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.

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

Límites de posición de la articulación, especificados como un vector de [min max] valores. En función del tipo de articulación, estos valores tienen diferentes definiciones.

• 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.

Ejemplo: [-pi/2, pi/2]

HomePosition — Posición inicial de la articulación

escalar

Posición inicial de la articulación, especificada como un escalar que depende 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 giratoria 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.

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 giratoria 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.

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 al marco del cuerpo principal.

Ejemplo: eye(4)

ChildToJointTransform — Transformación fija del marco 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 del marco 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 el marco 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 giratoria. 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 robot manipulador 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 facilitarlo, 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 robots de ejemplo como objetos rigidBodyTree.

load exampleRobots.mat

Visualice los detalles del robot Puma con showdetails.

showdetails(puma1)

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

 Idx    Body Name   Joint Name   Joint Type    Parent Name(Idx)   Children Name(s)
 ---    ---------   ----------   ----------    ----------------   ----------------
   1           L1         jnt1     revolute             base(0)   L2(2)  
   2           L2         jnt2     revolute               L1(1)   L3(3)  
   3           L3         jnt3     revolute               L2(2)   L4(4)  
   4           L4         jnt4     revolute               L3(3)   L5(5)  
   5           L5         jnt5     revolute               L4(4)   L6(6)  
   6           L6         jnt6     revolute               L5(5)   
--------------------

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

body3 = getBody(puma1,'L3');
childBody = body3.Children{1}

childBody = 
  rigidBody with properties:

            Name: 'L4'
           Joint: [1x1 rigidBodyJoint]
            Mass: 1
    CenterOfMass: [0 0 0]
         Inertia: [1 1 1 0 0 0]
          Parent: [1x1 rigidBody]
        Children: {[1x1 rigidBody]}
         Visuals: {}
      Collisions: {}

body3Copy = copy(body3);

Reemplace la articulación en el cuerpo L3. 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(puma1,'L3',newJoint);

showdetails(puma1)

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

 Idx    Body Name       Joint Name       Joint Type    Parent Name(Idx)   Children Name(s)
 ---    ---------       ----------       ----------    ----------------   ----------------
   1           L1             jnt1         revolute             base(0)   L2(2)  
   2           L2             jnt2         revolute               L1(1)   L3(3)  
   3           L3        prismatic            fixed               L2(2)   L4(4)  
   4           L4             jnt4         revolute               L3(3)   L5(5)  
   5           L5             jnt5         revolute               L4(4)   L6(6)  
   6           L6             jnt6         revolute               L5(5)   
--------------------

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

subtree = removeBody(puma1,'L4')

subtree = 
  rigidBodyTree with properties:

     NumBodies: 3
        Bodies: {[1x1 rigidBody]  [1x1 rigidBody]  [1x1 rigidBody]}
          Base: [1x1 rigidBody]
     BodyNames: {'L4'  'L5'  'L6'}
      BaseName: 'L3'
       Gravity: [0 0 0]
    DataFormat: 'struct'

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

removeBody(puma1,'L3');
addBody(puma1,body3Copy,'L2')
addSubtree(puma1,'L3',subtree)

showdetails(puma1)

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

 Idx    Body Name   Joint Name   Joint Type    Parent Name(Idx)   Children Name(s)
 ---    ---------   ----------   ----------    ----------------   ----------------
   1           L1         jnt1     revolute             base(0)   L2(2)  
   2           L2         jnt2     revolute               L1(1)   L3(3)  
   3           L3         jnt3     revolute               L2(2)   L4(4)  
   4           L4         jnt4     revolute               L3(3)   L5(5)  
   5           L5         jnt5     revolute               L4(4)   L6(6)  
   6           L6         jnt6     revolute               L5(5)   
--------------------

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

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