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

Sintaxis

robot = rigidBodyTree

robot = rigidBodyTree("MaxNumBodies",N,"DataFormat",dataFormat)

Descripción

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

NumBodies — Número de cuerpos

número entero

Esta propiedad o parámetro es de solo lectura.

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

Bodies — Lista de cuerpos rígidos

arreglo de celdas de identificadores

Esta propiedad o parámetro 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.

BodyNames — Nombres de cuerpos rígidos

arreglo de celdas de escalares de cadena | arreglo de celdas de vectores de caracteres

Esta propiedad o parámetro es de solo lectura.

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

BaseName — Nombre del robot base

'base' (predeterminado) | escalar de cadena | vector de caracteres

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

Gravity — Aceleración gravitacional experimentada por el robot

[0 0 0] m/s² (predeterminado) | vector [x y z]

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.

DataFormat — Formato de datos de entrada/salida de las funciones cinemáticas y dinámicas

"struct" (predeterminado) | "row" | "column"

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

Dinámicas

centerOfMass	Posición del centro de masa y jacobianas
externalForce	Componer matriz de fuerza externa respecto a la base
forwardDynamics	Aceleración de las articulaciones dados los par motores y los estados de articulación
geometricJacobian	Jacobianas geométricas para configurar robots
gravityTorque	Par motores de articulación que compensan la gravedad
inverseDynamics	Par motores de articulación requeridos para un movimiento determinado
massMatrix	Matriz de masa del espacio articular
velocityProduct	Par motores de articulación que cancelan las fuerzas inducidas por la velocidad

Cinemáticas

getTransform	Obtener una transformada entre marcos de cuerpo
homeConfiguration	Obtener la configuración inicial del robot
randomConfiguration	Generar una configuración de robot aleatoria

Comprobación de colisiones

checkCollision

Check if robot is in collision

Modificar la estructura de árbol de cuerpo rígido

addBody	Añadir un cuerpo al robot
addSubtree	Añadir un subárbol al robot
getBody	Obtener un identificador del cuerpo del robot por nombre
removeBody	Eliminar un cuerpo del robot
replaceBody	Reemplazar cuerpo del robot
replaceJoint	Reemplazar articulación en cuerpo
subtree	Crear un subárbol de un modelo de robot

Utilidades

copy	Copiar un modelo de robot
show	Mostrar modelo de robot en la figura
showdetails	Mostrar información del modelo de robot
writeAsFunction	Create rigidBodyTree code generating function

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

Especificar propiedades dinámicas a un árbol de cuerpo rígido

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)

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

Calcular las dinámicas directas debidas a fuerzas externas en el modelo de árbol de cuerpo rígido

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 fuerza a un cuerpo concreto y se especifica la gravedad para todo el robot.

Cargue un modelo de robot KUKA iiwa 14 de Robotics System Toolbox™ loadrobot. El robot se especifica como un objeto rigidBodyTree.

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

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

kukaIIWA14 = loadrobot("kukaIiwa14",DataFormat="row",Gravity=[0 0 -9.81]);

Obtenga la configuración inicial para el robot kukaIIWA14.

q = homeConfiguration(kukaIIWA14);

Especifique el vector de fuerza 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 fuerza, el vector de fuerza y la configuración actual del robot. wrench se da con relación al marco de cuerpo "iiwa_link_ee_kuka", que requiere que especifique la configuración del robot, q.

wrench = [0 0 0.5 0 0 0.3];
fext = externalForce(kukaIIWA14,"iiwa_link_ee_kuka",wrench,q);

Calcule las aceleraciones de las articulaciones resultantes debidas a la gravedad, con la fuerza externa aplicada al efector final "iiwa_link_ee_kuka" cuando kukaIIWA14 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(kukaIIWA14,q,[],[],fext)

qddot = 1×7

   -0.0023   -0.0112    0.0036   -0.0212    0.0067   -0.0075  499.9920

Calcular dinámicas inversas para configurar una articulación estática

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 las articulaciones y las fuerzas externas con otras sintaxis.

Cargue un Omron eCobra-600 de Robotics System Toolbox™ loadrobot, especificado como un objeto rigidBodyTree. Establezca la propiedad de gravedad y asegúrese de que el formato de datos se establece en "row". El formato de datos debe ser "row" o "column" para todos los cálculos de dinámica.

robot = loadrobot("omronEcobra600", DataFormat="row", Gravity=[0 0 -9.81]);

Genere una configuración aleatoria para robot.

q = randomConfiguration(robot);

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

tau = inverseDynamics(robot,q)

tau = 1×4

    0.0000    0.0000  -19.6200         0

Calcular el par motor de articulación para contrarrestar fuerzas externas

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 fuerza de seis elementos. Utilice la función externalForce y especifique el efector final para asignar adecuadamente la fuerza 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 Universal Robots UR5e de Robotics System Toolbox™ loadrobot, especificado como un objeto rigidBodyTree. Actualice la gravedad y establezca el formato de datos en "row". El formato de datos debe ser "row" o "column" para todos los cálculos de dinámica.

manipulator = loadrobot("universalUR5e", DataFormat="row", Gravity=[0 0 -9.81]);
showdetails(manipulator)

--------------------
Robot: (10 bodies)

 Idx                Body Name                         Joint Name                         Joint Type                Parent Name(Idx)   Children Name(s)
 ---                ---------                         ----------                         ----------                ----------------   ----------------
   1                     base         base_link-base_fixed_joint                              fixed                    base_link(0)   
   2        base_link_inertia        base_link-base_link_inertia                              fixed                    base_link(0)   shoulder_link(3)  
   3            shoulder_link                 shoulder_pan_joint                           revolute            base_link_inertia(2)   upper_arm_link(4)  
   4           upper_arm_link                shoulder_lift_joint                           revolute                shoulder_link(3)   forearm_link(5)  
   5             forearm_link                        elbow_joint                           revolute               upper_arm_link(4)   wrist_1_link(6)  
   6             wrist_1_link                      wrist_1_joint                           revolute                 forearm_link(5)   wrist_2_link(7)  
   7             wrist_2_link                      wrist_2_joint                           revolute                 wrist_1_link(6)   wrist_3_link(8)  
   8             wrist_3_link                      wrist_3_joint                           revolute                 wrist_2_link(7)   flange(9)  
   9                   flange                     wrist_3-flange                              fixed                 wrist_3_link(8)   tool0(10)  
  10                    tool0                       flange-tool0                              fixed                       flange(9)   
--------------------

Obtenga la configuración inicial para manipulator.

q = homeConfiguration(manipulator);

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

fext1 = externalForce(manipulator,"shoulder_link",[0 0 0.0 0.1 0 0]);

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

fext2 = externalForce(manipulator,"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(manipulator,q,[],[],fext1+fext2)

tau = 1×6

   -0.0233  -52.4189  -14.4896   -0.0100    0.0100   -0.0000

Mostrar el modelo de robot con geometrías visuales

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. Luego, 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",Collisions="off");

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",Collisions="on"); 

Más acerca de

Propiedades dinámicas

Si trabaja con dinámicas de robot, especifique la información de los distintos cuerpos del manipulador robótico utilizando estas propiedades de los objetos rigidBody:

• Mass: masa del cuerpo rígido en kilogramos.

• CenterOfMass: posición del centro de masa del cuerpo rígido, especificado como un vector con la forma [x y z]. El vector describe la ubicación del centro de masa del cuerpo rígido respecto a la estructura del cuerpo en metros. La función de objeto centerOfMass utiliza los valores de propiedad del cuerpo rígido al calcular el centro de masa de un robot.

• Inertia: inercia del cuerpo rígido, especificada como un vector con la forma [Ixx Iyy Izz Iyz Ixz Ixy]. El vector es relativo a la estructura del cuerpo en kilogramos por metro cuadrado. El tensor de inercia es una matriz definida positiva con la forma:

  

  Los primeros tres elementos del vector Inertia son el momento de inercia, que son los elementos en diagonal del tensor de inercia. Los últimos tres elementos son el producto de la inercia, que son los elementos fuera de la diagonal del tensor de inercia.

Para obtener información relacionada con todo el modelo de manipulador robótico, especifique estas propiedades del objeto rigidBodyTree:

• Gravity: aceleración gravitacional experimentada por el robot, especificada como un vector [x y z] en m/s². De forma predeterminada, no existe aceleración gravitacional.

• DataFormat: formato de los datos de entrada y salida de las funciones cinemáticas y dinámicas, especificado como "struct", "row" o "column".

Ecuaciones dinámicas

La dinámica de un cuerpo rígido de manipulador se rige por esta ecuación:

$$\frac{d}{dt}\left[\begin{array}{c}q\\ \dot{q}\end{array}\right]=\left[\begin{array}{c}\dot{q}\\ M{(q)}^{-1}\left(-C(q,\dot{q})\dot{q}-G(q)-J{(q)}^T{f}_{Ext}+\tau \right)\end{array}\right]$$

también expresada como:

$$M(q)\ddot{q}=-C(q,\dot{q})\dot{q}-G(q)-J{(q)}^T{f}_{Ext}+\tau$$

donde:

• $$M(q)$$: es una matriz de masa de espacio articular basada en la configuración actual del robot. Calcule esta matriz utilizando la función de objeto massMatrix.

• $$C(q,\dot{q})$$: son los términos de Coriolis, que se multiplican por $$\dot{q}$$ para calcular el producto de velocidad. Calcule el producto de velocidad utilizando la función de objeto velocityProduct.

• $$G(q)$$: son las fuerzas y los par motores de gravedad necesarios para que todas las articulaciones mantengan sus posiciones en la gravedad especificada Gravity. Calcule el par motor de gravedad utilizando la función de objeto gravityTorque.

• $$J(q)$$: es la jacobiana geométrica de la configuración de articulación especificada. Calcule la jacobiana geométrica utilizando la función de objeto geometricJacobian.

• $$f_{Ext}$$: es una matriz de las fuerzas externas aplicadas al cuerpo rígido. Genere las fuerzas externas utilizando la función de objeto externalForce.

• $$\tau$$: son las fuerzas y los par motores de articulación, aplicados directamente como un vector a cada articulación.

• $$q,\dot{q},\ddot{q}$$: son la configuración de articulación, las velocidades de articulación y las aceleraciones de las articulaciones, respectivamente, como vectores individuales. Para las articulaciones rotativas, especifique los valores en radianes, rad/s y rad/s², respectivamente. Para las articulaciones prismáticas, especifíquelos en metros, m/s y m/s².

Para calcular la dinámica directamente, utilice la función de objeto forwardDynamics. Esta función calcula las aceleraciones de las articulaciones para las combinaciones especificadas de las entradas anteriores.

Para realizar un conjunto de movimientos determinado, utilice la función de objeto inverseDynamics. La función calcula los par motores de articulación que son necesarios para obtener la configuración, así como las velocidades, aceleraciones y fuerzas externas especificadas.

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

Generación de código C/C++

Genere código C y C++ mediante MATLAB® Coder™.

Indicaciones y limitaciones de uso:

Cuando cree el objeto rigidBodyTree, utilice la sintaxis que especifica MaxNumBodies como el límite superior para añadir cuerpos al modelo de robot. También debe especificar la propiedad DataFormat como un par nombre-valor. Por ejemplo:

robot = rigidBodyTree("MaxNumBodies",15,"DataFormat","row")

Para minimizar el uso de datos, restrinja el límite superior a un número aproximado al número de cuerpos previsto del modelo. La generación de código admite todos los formatos de datos. Para usar las funciones de dinámica, el formato de datos debe configurarse en "row" o "column".

Las funciones show y showdetails no admiten la generación de código.

Historial de versiones

Introducido en R2016b

R2024a: Soporte de asignación de memoria estática

Estas funciones de objeto rigidBodyTree admiten tamaños de memoria estática para la generación de código deshabilitando la asignación de memoria dinámica.

• centerOfMass

• externalForce

• forwardDynamics

• geometricJacobian

• gravityTorque

• inverseDynamics

• massMatrix

• velocityProduct

• getTransform

• homeConfiguration

• randomConfiguration

Para obtener más información sobre cómo deshabilitar la asignación de memoria dinámica, consulte Set Dynamic Memory Allocation Threshold (MATLAB Coder).

R2019b: Se ha modificado el nombre de rigidBodyTree

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

Consulte también

importrobot | inverseKinematics | generalizedInverseKinematics | rigidBodyJoint | rigidBody

Temas

• Construir un robot paso a paso
• Solve Inverse Kinematics for Closed Loop Linkages
• Calcular los pares motores de las articulaciones para equilibrar una fuerza y momento de punto final
• Modelo de robot de árbol de cuerpo rígido

Sitios web externos

• Manipuladores robóticos (recursos para enseñanza de MathWorks)