Main Content

rigidBodyTree

Crear robot estructurado en árbol

Descripción

Es una representación de la conectividad de sólidos rígidos con juntas.rigidBodyTree Utilice esta clase para construir modelos de manipuladores de robots en .MATLAB® Si tiene un modelo de robot especificado mediante el formato de descripción de robot unificado (URDF), utilice para importar su modelo de robot.importrobot

Un modelo de árbol de sólido rígido se compone de sólidos rígidos como objetos.RigidBody Cada cuerpo rígido tiene un objeto asociado que define cómo puede moverse en relación con su cuerpo primario.rigidBodyJoint Uso setFixedTransform para definir la transformación fija entre el marco de una articulación y el marco de uno de los sólidos adyacentes. Puede agregar, reemplazar o quitar sólidos rígidos del modelo utilizando los métodos de la clase.RigidBodyTree

Los cálculos de la dinámica del robot también son posibles. Especifique las propiedades , , y para cada una en el modelo de robot.MassCenterOfMassInertiarigidBody Puede calcular la dinámica hacia delante e inversa con o sin fuerzas externas y calcular cantidades dinámicas dadas las entradas de juntas y juntas del robot. Para utilizar las funciones relacionadas con la dinámica, establezca la propiedad en o .DataFormat"row""column"

Para un modelo de árbol de cuerpo rígido determinado, también puede utilizar el modelo de robot para calcular los ángulos de unión para las posiciones de efecto final deseadas utilizando los algoritmos de cinemática inversa robótica. Especifique el modelo de árbol de sólido rígido al utilizar o .inverseKinematicsgeneralizedInverseKinematics

el show método admite la visualización de mallas corporales. Las mallas se especifican como archivos y se pueden agregar a sólidos rígidos individuales utilizando.stl addVisual. Además, de forma predeterminada, la función carga todos los archivos accesibles especificados en su modelo de robot URDF.importrobot.stl

Creación

Descripción

ejemplo

robot = rigidBodyTree crea un objeto robot estructurado en árbol. Añadir le sentidos rígidos usando addBody.

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

Propiedades

expandir todo

Esta propiedad es de solo lectura.

Número de sólidos en el modelo de robot (sin incluir la base), devueltos como un entero.

Esta propiedad es de solo lectura.

Lista de sólidos rígidos en el modelo de robot, devueltos como una matriz de manejadores de celdas. Utilice esta lista para acceder a objetos específicos del modelo.RigidBody También puede llamar getBody para conseguir un cuerpo por su nombre.

Esta propiedad es de solo lectura.

Nombres de sólidos rígidos, devueltos como una matriz de celdas de vectores de caracteres.

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

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

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

Funciones del objeto

addBodyAdd body to robot
addSubtreeAdd subtree to robot
centerOfMassCenter of mass position and Jacobian
copyCopy robot model
externalForceCompose external force matrix relative to base
forwardDynamicsJoint accelerations given joint torques and states
geometricJacobianJacobiano geométrico para configuración de robots
gravityTorqueJoint torques that compensate gravity
getBodyGet robot body handle by name
getTransformGet transform between body frames
homeConfigurationGet home configuration of robot
inverseDynamicsRequired joint torques for given motion
massMatrixJoint-space mass matrix
randomConfigurationGenerate random configuration of robot
removeBodyRemove body from robot
replaceBodyReplace body on robot
replaceJointReplace joint on body
showMostrar modelo robot en una figura
showdetailsShow details of robot model
subtreeCreate subtree from robot model
velocityProductJoint torques that cancel velocity-induced forces

Ejemplos

contraer todo

Agregue un sólido rígido y una junta correspondiente a un árbol de cuerpo rígido. Cada objeto r contiene un objeto y debe agregarse a la r mediante .igidBodyrigidBodyJointigidBodyTreeaddBody

Cree un árbol de sólido rígido.

rbtree = rigidBodyTree;

Cree un sólido rígido con un nombre único.

body1 = rigidBody('b1');

Cree una unión revoluta. De forma predeterminada, el objeto r viene con una unión fija.igidBody Reemplace la unión asignando un nuevo objeto a la propiedad.rigidBodyJointbody1.Joint

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

Agregue el cuerpo rígido al árbol. Especifique el nombre del sólido al que va a conectar el sólido rígido. Dado que este es el primer cuerpo, utilice el nombre base del árbol.

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

Utilícelo en el árbol para confirmar que el cuerpo rígido y la articulación se agregaron correctamente.showdetails

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. Cada sólido rígido se agrega de uno en uno, con la transformación child-to-parent especificada por el objeto de unión.

Los parámetros DH definen la geometría del robot en relación con cómo se une cada cuerpo rígido a su padre. Para mayor comodidad, configure los parámetros para el robot Puma560 en una matriz. El robot Puma es un manipulador de cadenas serie. Los parámetros DH son relativos a la línea anterior de la matriz, correspondiente a la unió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;

Crea el primer cuerpo rígido y agréguelo al robot. Para añadir un sólido rígido:

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

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

  3. Se utiliza para especificar la transformación cuerpo a cuerpo mediante parámetros DH.setFixedTransform El último elemento de los parámetros DH, , se omite porque el ángulo depende de la posición de la unión.theta

  4. Llamada para fijar la primera junta del cuerpo al marco base del robot.addBody

body1 = rigidBody('body1'); jnt1 = rigidBodyJoint('jnt1','revolute');  setFixedTransform(jnt1,dhparams(1,:),'dh'); body1.Joint = jnt1;  addBody(robot,body1,'base')

Crea y añade otros cuerpos rígidos al robot. Especifique el nombre del cuerpo anterior al llamar para adjuntarlo.addBody Cada transformación fija es relativa al marco de coordenadas de unió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')

Compruebe que el robot se ha creado correctamente mediante la función o. enumera todos los cuerpos en la ventana de comandos MATLAB®. muestra el robot con una configuración dada (hogar por defecto).showdetailsshowshowdetailsshow Llamadas para modificar los límites del eje y ocultar las etiquetas del eje.axis

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

Realice cambios en un objeto existente.rigidBodyTree Puede obtener juntas, sólidos y subárboles de sustitución en el árbol de cuerpo rígido.

Cargar robots de ejemplo como objetos.rigidBodyTree

load exampleRobots.mat

Vea los detalles del robot Puma usando .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 hijo del cuerpo es el cuerpo.L3L4 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: {}  
body3Copy = copy(body3);

Vuelva a colocar la articulación en el cuerpo.L3 Debe crear un nuevo objeto y utilizarlo para asegurarse de que la geometría del cuerpo aguas abajo no se ve afectada.JointreplaceJoint Llame si es necesario para definir una transformación entre los cuerpos en lugar de con las matrices de identidad predeterminadas.setFixedTransform

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

Retire un cuerpo entero y obtenga el subárbol resultante usando .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'  

Retire el cuerpo modificado.L3 Agregue el sólido copiado original al cuerpo, seguido del subárbol devuelto.L3L2 El modelo robot sigue siendo el mismo. Vea una comparación detallada a través de .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 de dinámica para calcular pares y aceleraciones conjuntas, especifique las propiedades de dinámica para el objeto y .rigidBodyTreerigidBody

Cree un modelo de árbol de sólido rígido. Cree dos sólidos rígidos para adjuntarlos.

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

Especifique las uniones que se asocian a los sólidos. Establezca la transformación fija de en .body2body1 Esta transformación es de 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 de dinámica para los dos sólidos. Agregue los cuerpos al modelo de robot. En este ejemplo, se proporcionan valores básicos para una varilla ( ) con una masa esférica adjunta ( ).body1body2

body1.Mass = 2; body1.CenterOfMass = [0.5 0 0]; body1.Inertia = [0.167 0.001 0.167 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');

Calcular el centro de la posición de masa de todo el robot. Trazar 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)

Cambia 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

Calcule las aceleraciones de las articulaciones resultantes para una configuración de robot dada con fuerzas y fuerzas externas aplicadas debido a la gravedad. Una llave se aplica a un cuerpo específico con la gravedad especificada para todo el robot.

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

load exampleRobots.mat lbr

Establezca el formato de datos en .'row' Para todos los cálculos dinámicos, el formato de datos debe ser o .'row''column'

lbr.DataFormat = 'row';

Ajuste la gravedad. De forma predeterminada, se supone que la gravedad es cero.

lbr.Gravity = [0 0 -9.81];

Obtenga la configuración de inicio para el robot.lbr

q = homeConfiguration(lbr);

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

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

Calcular las aceleraciones de las articulaciones resultantes debido a la gravedad, con la fuerza externa aplicada al efector final cuando está en su configuración de inicio.'tool0'lbr Se supone que las velocidades de unión y los pares de torsión de unión son cero (entrada como vector vacío).[]

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

Utilice la función para calcular los pares de unión necesarios para mantener estáticamente una configuración específica del robot.inverseDynamics También puede especificar las velocidades de unión, las aceleraciones de juntas y las fuerzas externas mediante otras sintaxis.

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

load exampleRobots.mat lbr

Establezca el formato de datos en .'row' Para todos los cálculos dinámicos, el formato de datos debe ser o .'row''column'

lbr.DataFormat = 'row';

Establezca la propiedad para dar una aceleración gravitacional específica.Gravity

lbr.Gravity = [0 0 -9.81];

Genere una configuración aleatoria para .lbr

q = randomConfiguration(lbr);

Calcular los pares de unión necesarios para mantener estáticamente esa configuración.lbr

tau = inverseDynamics(lbr,q);

Utilice la función para generar matrices de fuerza que se apliquen a un modelo de árbol de sólido rígido.externalForce La matriz de fuerza es un vector -by-6 que tiene una fila para cada articulación en el robot para aplicar una llave de seis elementos.m Utilice la función y especifique el efector final para asignar correctamente la llave a la fila correcta de la matriz.externalForce Puede agregar varias matrices de fuerza juntas para aplicar varias fuerzas a un robot.

Para calcular los pares de unión que contrarrestan estas fuerzas externas, utilice la función.inverseDynamics

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

load exampleRobots.mat lbr

Establezca el formato de datos en .'row' Para todos los cálculos dinámicos, el formato de datos debe ser o .'row''column'

lbr.DataFormat = 'row';

Establezca la propiedad para dar una aceleración gravitacional específica.Gravity

lbr.Gravity = [0 0 -9.81];

Obtenga la configuración de inicio 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);

Calcular los pares de unión necesarios para equilibrar las fuerzas externas. Para combinar las fuerzas, agregue las matrices de fuerza. Se supone que las velocidades y aceleraciones de las articulaciones son cero (entrada como ).[]

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

Puede importar robots que tengan archivos asociados con el archivo de formato de descripción de robots unificados (URDF) para describir las geometrías visuales del robot..stl Cada sólido rígido tiene una geometría visual individual especificada. La función analiza el archivo URDF para obtener el modelo de robot y las geometrías visuales.importrobot Utilice la función para visualizar el modelo de robot en una figura.show A continuación, puede interactuar con el modelo haciendo clic en componentes para inspeccionarlos y haciendo clic con el botón derecho para alternar la visibilidad.

Importe un modelo de robot como un archivo URDF. Las ubicaciones de los archivos deben especificarse correctamente en este URDF..stl Para agregar otros archivos a sólidos rígidos individuales, consulte ..stladdVisual

robot = importrobot('iiwa14.urdf');

Visualice el robot con el modelo visual asociado. Haga clic en sólidos o marcos para inspeccionarlos. Haga clic con el botón derecho del botón derecho del botón derecho del botón del programa para alternar la visibilidad de cada geometría visual.

show(robot);

Consideraciones de compatibilidad

expandir todo

Cambio de comportamiento en versión futura

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

Introducido en R2016b