Main Content

addBody

Añadir un cuerpo al robot

contraer todo en la página

Sintaxis

addBody(robot,body,parentname)

Descripción

ejemplo

addBody(robot,body,parentname) añade un cuerpo rígido al objeto robot y se acopla al elemento principal del cuerpo rígido especificado por parentname. La propiedad body define cómo se mueve este cuerpo respecto al cuerpo principal.

Ejemplos

contraer todo

Abrir script en vivo

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)   
--------------------
Abrir script en vivo

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.

Abrir script en vivo

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

Argumentos de entrada

contraer todo

Modelo de robot, especificado como un objeto rigidBodyTree.

Cuerpo rígido, especificado como un objeto rigidBody.

Nombre del cuerpo principal, especificado como escalar de cadena o vector de caracteres. Este cuerpo principal ya debe existir en el modelo de robot. El cuerpo nuevo se acopla a este cuerpo principal.

Tipos de datos: char | string

Capacidades ampliadas

Historial de versiones

Introducido en R2016b

Consulte también

| | |

Sitios web externos