Main Content

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.

rigidBodyTree

Cree un robot con estructura de árbol

Descripción

rigidBodyTree es una representación de la conectividad de cuerpos rígidos con articulaciones. Utilice esta clase para construir modelos de manipuladores robóticos en MATLAB®. Si tiene un modelo de robot especificado con el formato de descripción de robot unificado (URDF), utilice importrobot para importar el modelo de robot.

Un modelo de árbol de cuerpo rígido está compuesto por cuerpos rígidos como objetos rigidBody. Cada cuerpo rígido tiene un objeto rigidBodyJoint relacionado que define cómo se puede mover respecto a su cuerpo primario. Utilice setFixedTransform para definir la transformación fija entre el marco de una articulación y el marco de uno de los cuerpos adyacentes. Puede añadir, reemplazar o eliminar cuerpos rígidos del modelo utilizando los métodos de la clase RigidBodyTree.

También es posible calcular las dinámicas de robot. Especifique las propiedades Mass, CenterOfMass y Inertia en cada rigidBody del modelo de robot. Puede calcular dinámicas directas e inversas con o sin fuerzas externas y calcular cantidades de dinámica a partir de las entradas de las articulaciones y los movimientos de las articulaciones del robot. Para usar las funciones relacionadas con las dinámicas, establezca la propiedad DataFormat en "row" o "column".

En el caso de un modelo de árbol de cuerpo rígido, también puede utilizar el modelo de robot para calcular los ángulos de las articulaciones para las posiciones deseadas del efector final utilizando los algoritmos robóticos de cinemática inversa. Especifique el modelo de árbol de cuerpo rígido utilizando inverseKinematics o generalizedInverseKinematics.

El método show admite la visualización de mallas de cuerpo. Las mallas se especifican como archivos .stl y se pueden añadir a cuerpos rígidos individuales utilizando addVisual. Por otro lado, de forma predeterminada, la función importrobot carga todos los archivos .stl accesibles que están especificados en su modelo de robot URDF.

Creación

Descripción

ejemplo

robot = rigidBodyTree crea un objeto de robot con estructura de árbol. Añádale cuerpos rígidos utilizando addBody.

robot = rigidBodyTree("MaxNumBodies",N,"DataFormat",dataFormat) especifica un límite superior para el número de cuerpos permitidos en el robot al generar código. También debe especificar la propiedad DataFormat como un par nombre-valor.

Propiedades

expandir todo

Esta propiedad es de solo lectura.

Número de cuerpos del modelo de robot (sin incluir la base), devuelto como un número entero.

Esta propiedad es de solo lectura.

Lista de cuerpos rígidos en el modelo de robot, devuelta como un arreglo de celdas de identificadores. Utilice esta lista para acceder a objetos RigidBody específicos en el modelo. También puede llamar a getBody para obtener un cuerpo por su nombre.

Esta propiedad es de solo lectura.

Nombres de cuerpos rígidos, devueltos como un arreglo de celdas de vectores de caracteres.

Nombre del robot base, devuelto como un vector de caracteres o un escalar de cadena.

Aceleración gravitacional experimentada por el robot, especificada como un vector [x y z] en metros por segundo al cuadrado. Cada elemento se corresponde con la aceleración del marco base del robot en esa dirección.

Formato de datos de entrada/salida de las funciones cinemáticas y dinámicas, especificado como "struct", "row" o "column". Para utilizar funciones dinámicas, debe utilizar "row" o "column".

Funciones del objeto

addBodyAdd body to robot
addSubtreeAdd subtree to robot
centerOfMassCentro de posición de masa y jacobianas
checkCollisionCheck if robot is in collision
copyCopy robot model
externalForceCompose external force matrix relative to base
forwardDynamicsJoint accelerations given joint torques and states
geometricJacobianJacobianas geométricas para configurar robots
gravityTorqueJoint torques that compensate gravity
getBodyGet robot body handle by name
getTransformObtener una transformada entre marcos de cuerpo
homeConfigurationObtener la configuración inicial del robot
inverseDynamicsRequired joint torques for given motion
massMatrixMatriz de masa del espacio articular
randomConfigurationGenerar una configuración de robot aleatoria
removeBodyRemove body from robot
replaceBodyReplace body on robot
replaceJointReplace joint on body
showShow robot model in figure
showdetailsShow details of robot model
subtreeCreate subtree from robot model
velocityProductJoint torques that cancel velocity-induced forces
writeAsFunctionCreate rigidBodyTree code generating function

Ejemplos

contraer todo

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)   
--------------------

Utilice los parámetros Denavit-Hartenberg (DH) del robot Puma560® para construir un robot. Los cuerpos rígidos se añaden uno tras otro con la transformada de primario a 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 primario. 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 línea 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 Comput. Soc. Press, 1994, págs. 1608–13. DOI.org (Crossref), doi:10.1109/ROBOT.1994.351360.

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)   
--------------------

Para utilizar funciones dinámicas para calcular los par motores de articulación y las aceleraciones, especifique las propiedades dinámicas del objeto rigidBodyTree y rigidBody.

Cree un modelo de árbol de cuerpo rígido. Cree dos cuerpos rígidos para acoplar a este árbol.

robot = rigidBodyTree('DataFormat','row');
body1 = rigidBody('body1');
body2 = rigidBody('body2');

Especifique articulaciones para acoplar a los cuerpos. Establezca la transformación fija de body2 a body1. Esta transformada es 1 m en la dirección x.

joint1 = rigidBodyJoint('joint1','revolute');
joint2 = rigidBodyJoint('joint2');
setFixedTransform(joint2,trvec2tform([1 0 0]))
body1.Joint = joint1;
body2.Joint = joint2;

Especifique las propiedades dinámicas de los dos cuerpos. Añada los cuerpos al modelo de robot. Para este ejemplo se proporcionan los valores básicos de una varilla (body1) con una masa esférica acoplada (body2).

body1.Mass = 2;
body1.CenterOfMass = [0.5 0 0];
body1.Inertia = [0.001 0.67 0.67 0 0 0];

body2.Mass = 1;
body2.CenterOfMass = [0 0 0];
body2.Inertia = 0.0001*[4 4 4 0 0 0];

addBody(robot,body1,'base');
addBody(robot,body2,'body1');

Calcule la posición del centro de masa de todo el robot. Represente la posición en el robot. Mueva la vista al plano xy.

comPos = centerOfMass(robot);

show(robot);
hold on
plot(comPos(1),comPos(2),'or')
view(2)

Figure contains an axes object. The axes object contains 6 objects of type patch, line. These objects represent base, body1, body2.

Cambie la masa del segundo cuerpo. Observe el cambio en el centro de masa.

body2.Mass = 20;
replaceBody(robot,'body2',body2)

comPos2 = centerOfMass(robot);
plot(comPos2(1),comPos2(2),'*g')
hold off

Figure contains an axes object. The axes object contains 7 objects of type patch, line. These objects represent base, body1, body2.

Calcule las aceleraciones de las articulaciones resultantes para una determinada configuración de robot a la que se aplican fuerzas externas y fuerzas debidas a la gravedad. Se aplica una llave a un cuerpo concreto y se especifica la gravedad para todo el robot.

Cargue un modelo de robot predefinido KUKA LBR, que se especifica como un objeto RigidBodyTree.

load exampleRobots.mat lbr

Configure el formato de datos en 'row'. El formato de datos debe ser 'row' o 'column' para todos los cálculos de dinámica.

lbr.DataFormat = 'row';

Establezca la gravedad. De forma predeterminada, se asume que la gravedad es cero.

lbr.Gravity = [0 0 -9.81];

Obtenga la configuración inicial para el robot lbr.

q = homeConfiguration(lbr);

Especifique el vector de llave que representa las fuerzas externas que experimenta el robot. Utilice la función externalForce para generar la matriz de fuerzas externas. Especifique el modelo de robot, el efector final que experimenta la llave, el vector de llave y la configuración actual del robot. wrench se da con relación al marco del cuerpo 'tool0', que requiere que especifique la configuración del robot, q.

wrench = [0 0 0.5 0 0 0.3];
fext = externalForce(lbr,'tool0',wrench,q);

Calcule las aceleraciones de las articulaciones resultantes debidas a la gravedad, con la fuerza externa aplicada al efector final 'tool0' cuando lbr está en su configuración inicial. Las velocidades y los par motores de articulación se asumen como cero (se introducen como un vector vacío, []).

qddot = forwardDynamics(lbr,q,[],[],fext);

Utilice la función inverseDynamics para calcular los par motores de articulación necesarios para mantener estática una configuración de robot concreta. También puede especificar las velocidades y aceleraciones de articulación y las fuerzas externas con otras sintaxis.

Cargue un modelo de robot predefinido KUKA LBR, que se especifica como un objeto RigidBodyTree.

load exampleRobots.mat lbr

Configure el formato de datos en 'row'. El formato de datos debe ser 'row' o 'column' para todos los cálculos de dinámica.

lbr.DataFormat = 'row';

Establezca la propiedad Gravity para generar una aceleración gravitacional concreta.

lbr.Gravity = [0 0 -9.81];

Genere una configuración aleatoria para lbr.

q = randomConfiguration(lbr);

Calcule los par motores de articulación necesarios para lbr, para mantener estática esa configuración.

tau = inverseDynamics(lbr,q);

Utilice la función externalForce para generar matrices de fuerza y aplicarlas a un modelo de árbol de cuerpo rígido. La matriz de fuerza es un vector de m por 6 que tiene una fila para cada articulación del robot para aplicar una llave de seis elementos. Utilice la función externalForce y especifique el efector final para asignar adecuadamente la llave a la fila correcta de la matriz. Puede añadir múltiples matrices de fuerza a la vez para aplicar múltiples fuerzas a un robot.

Para calcular los par motores de articulación que contrarrestan estas fuerzas externas, utilice la función inverseDynamics.

Cargue un modelo de robot predefinido KUKA LBR, que se especifica como un objeto RigidBodyTree.

load exampleRobots.mat lbr

Configure el formato de datos en 'row'. El formato de datos debe ser 'row' o 'column' para todos los cálculos de dinámica.

lbr.DataFormat = 'row';

Establezca la propiedad Gravity en una aceleración gravitacional concreta.

lbr.Gravity = [0 0 -9.81];

Obtenga la configuración inicial para lbr.

q = homeConfiguration(lbr);

Establezca la fuerza externa en link1. El vector de llave de entrada se expresa en el marco base.

fext1 = externalForce(lbr,'link_1',[0 0 0.0 0.1 0 0]);

Establezca la fuerza externa en el efector final, tool0. El vector de llave de entrada se expresa en el marco tool0.

fext2 = externalForce(lbr,'tool0',[0 0 0.0 0.1 0 0],q);

Calcule los par motores de articulación necesarios para equilibrar las fuerzas externas. Para combinar las fuerzas, añada las matrices de fuerza juntas. Las aceleraciones y las velocidades de las articulaciones se asumen como cero (se introducen como []).

tau = inverseDynamics(lbr,q,[],[],fext1+fext2);

Puede importar robots que tienen archivos .stl relacionados con el archivo de formato de descripción de robot unificado (URDF) para describir las geometrías visuales del robot. Cada cuerpo rígido tiene especificada una geometría visual individual. La función importrobot analiza el archivo URDF para obtener el modelo de robot y las geometrías visuales. La función asume que la geometría visual y la geometría de colisión del robot son iguales y asigna las geometrías visuales como geometrías de colisión de los cuerpos correspondientes.

Utilice la función show para mostrar la geometría visual y de colisión del modelo de robot en una figura. A continuación, puede interactuar con el modelo haciendo clic en componentes para inspeccionarlos y haciendo clic con el botón secundario para alternar la visibilidad.

Importe un modelo de robot como un archivo URDF. Las ubicaciones de los archivos .stl se deben especificar correctamente en este URDF. Para añadir otros archivos .stl a cuerpos rígidos individuales, consulte addVisual.

robot = importrobot('iiwa14.urdf');

Visualice el robot con el modelo visual correspondiente. Haga clic en los cuerpos o los marcos para inspeccionarlos. Haga clic con el botón secundario en los cuerpos para alternar la visibilidad de cada geometría visual.

show(robot,'visuals','on','collision','off');

Figure contains an axes object. The axes object contains 29 objects of type patch, line. These objects represent world, iiwa_link_0, iiwa_link_1, iiwa_link_2, iiwa_link_3, iiwa_link_4, iiwa_link_5, iiwa_link_6, iiwa_link_7, iiwa_link_ee, iiwa_link_ee_kuka, iiwa_link_0_mesh, iiwa_link_1_mesh, iiwa_link_2_mesh, iiwa_link_3_mesh, iiwa_link_4_mesh, iiwa_link_5_mesh, iiwa_link_6_mesh, iiwa_link_7_mesh.

Visualice el robot con las geometrías de colisión correspondientes. Haga clic en los cuerpos o los marcos para inspeccionarlos. Haga clic con el botón secundario en los cuerpos para alternar la visibilidad de cada geometría de colisión.

show(robot,'visuals','off','collision','on'); 

Figure contains an axes object. The axes object contains 29 objects of type patch, line. These objects represent world, iiwa_link_0, iiwa_link_1, iiwa_link_2, iiwa_link_3, iiwa_link_4, iiwa_link_5, iiwa_link_6, iiwa_link_7, iiwa_link_ee, iiwa_link_ee_kuka, iiwa_link_0_mesh, iiwa_link_1_mesh, iiwa_link_2_mesh, iiwa_link_3_mesh, iiwa_link_4_mesh, iiwa_link_5_mesh, iiwa_link_6_mesh, iiwa_link_7_mesh, iiwa_link_0_coll_mesh, iiwa_link_1_coll_mesh, iiwa_link_2_coll_mesh, iiwa_link_3_coll_mesh, iiwa_link_4_coll_mesh, iiwa_link_5_coll_mesh, iiwa_link_6_coll_mesh, iiwa_link_7_coll_mesh.

Más acerca de

expandir todo

Referencias

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

[2] Siciliano, Bruno, Lorenzo Sciavicco, Luigi Villani, and Giuseppe Oriolo. Robotics: Modelling, Planning and Control. London: Springer, 2009.

Capacidades ampliadas

Historial de versiones

Introducido en R2016b

expandir todo