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

addBody	Añadir un cuerpo al robot
addSubtree	Añadir un subárbol al robot
centerOfMass	Centro de posición de masa y jacobianas
checkCollision	Check if robot is in collision
copy	Copiar un modelo de robot
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
getBody	Obtener un identificador del cuerpo del robot por nombre
getTransform	Obtener una transformada entre marcos de cuerpo
homeConfiguration	Obtener la configuración inicial del robot
inverseDynamics	Par motores de articulación requeridos para un movimiento determinado
massMatrix	Matriz de masa del espacio articular
randomConfiguration	Generar una configuración de robot aleatoria
removeBody	Eliminar un cuerpo del robot
replaceBody	Reemplazar cuerpo del robot
replaceJoint	Replace joint on body
show	Mostrar modelo de robot en la figura
showdetails	Mostrar información del modelo de robot
subtree	Create subtree from robot model
velocityProduct	Par motores de articulación que cancelan las fuerzas inducidas por la velocidad
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 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 Comput. 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)   
--------------------

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

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

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 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 para generar 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);

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. 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');

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

Más acerca de

propiedades dinámicas

Si trabaja con dinámicas de robot, especifique la información de los distintos cuerpos del robot manipulador 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 al marco 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 al marco 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 robot manipulador, 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 giratorias, 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™.

Notas 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. Todos los formatos de datos son compatibles con la generación de código. Para usar las funciones de dinámica, el formato de datos debe configurarse en "row" o "column".

Las funciones show y showdetails no son compatibles con la generación de código.

Historial de versiones

Introducido en R2016b

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
• Compute Joint Torques To Balance An Endpoint Force and Moment
• Modelo de robot de árbol de cuerpo rígido

×

Abrir ejemplo

Tiene una versión modificada de este ejemplo. ¿Desea abrir este ejemplo con sus modificaciones?

No, sobrescribir la versión modificada Sí