addSubtree

Añadir un subárbol al robot

Sintaxis

addSubtree(robot,bodyname,subtreerobot)

addSubtree(___,ReplaceBase=MODE)

Descripción

addSubtree(robot,bodyname,subtreerobot) acopla el modelo de robot, newSubtree, a un modelo de robot existente, robot, en el cuerpo especificado por bodyname. La base del subárbol no se añade como un cuerpo.

ejemplo

addSubtree(___,ReplaceBase=MODE) reemplaza la base actual del subárbol por bodyname cuando MODE se establece en true. MODE es verdadero de forma predeterminada.

Ejemplos

contraer todo

Modificar un modelo de árbol de cuerpo rígido

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

Acoplar una pinza a un modelo de manipulador de árbol de cuerpo rígido

Abrir script en vivo

Cargue el manipulador robótico UR10 de Robotics System Toolbox™ loadrobot. Está especificado como un objeto rigidBodyTree.

ur10 = loadrobot("universalUR10");

Cargue la pinza Robotiq 2F-85 para acoplarla al brazo del manipulador.

gripper = loadrobot("robotiq2F85");

Acople la pinza al extremo del brazo UR10.

addSubtree(ur10, 'tool0', gripper, ReplaceBase=false);

Visualice el robot with show y lea los detalles del robot con showdetails para visualizar la articulación modificada del objeto rigidBodyTree.

show(ur10)

ans = 
  Axes (Primary) with properties:

             XLim: [-1.5000 1.5000]
             YLim: [-1.5000 1.5000]
           XScale: 'linear'
           YScale: 'linear'
    GridLineStyle: '-'
         Position: [0.1300 0.1100 0.7750 0.8150]
            Units: 'normalized'

  Use GET to show all properties

showdetails(ur10)

--------------------
Robot: (21 bodies)

 Idx                      Body Name                            Joint Name                            Joint Type                      Parent Name(Idx)   Children Name(s)
 ---                      ---------                            ----------                            ----------                      ----------------   ----------------
   1                      base_link                           world_joint                                 fixed                              world(0)   base(2)  shoulder_link(3)  
   2                           base            base_link-base_fixed_joint                                 fixed                          base_link(1)   
   3                  shoulder_link                    shoulder_pan_joint                              revolute                          base_link(1)   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)   ee_link(9)  tool0(10)  
   9                        ee_link                        ee_fixed_joint                                 fixed                       wrist_3_link(8)   
  10                          tool0        wrist_3_link-tool0_fixed_joint                                 fixed                       wrist_3_link(8)   robotiq_arg2f_base_link(11)  
  11        robotiq_arg2f_base_link           robotiq_arg2f_base_link_jnt                                 fixed                             tool0(10)   left_outer_knuckle(12)  left_inner_knuckle(16)  right_inner_knuckle(17)  right_outer_knuckle(18)  
  12             left_outer_knuckle                          finger_joint                              revolute           robotiq_arg2f_base_link(11)   left_outer_finger(13)  
  13              left_outer_finger               left_outer_finger_joint                                 fixed                left_outer_knuckle(12)   left_inner_finger(14)  
  14              left_inner_finger               left_inner_finger_joint                              revolute                 left_outer_finger(13)   left_inner_finger_pad(15)  
  15          left_inner_finger_pad           left_inner_finger_pad_joint                                 fixed                 left_inner_finger(14)   
  16             left_inner_knuckle              left_inner_knuckle_joint                              revolute           robotiq_arg2f_base_link(11)   
  17            right_inner_knuckle             right_inner_knuckle_joint                              revolute           robotiq_arg2f_base_link(11)   
  18            right_outer_knuckle             right_outer_knuckle_joint                              revolute           robotiq_arg2f_base_link(11)   right_outer_finger(19)  
  19             right_outer_finger              right_outer_finger_joint                                 fixed               right_outer_knuckle(18)   right_inner_finger(20)  
  20             right_inner_finger              right_inner_finger_joint                              revolute                right_outer_finger(19)   right_inner_finger_pad(21)  
  21         right_inner_finger_pad          right_inner_finger_pad_joint                                 fixed                right_inner_finger(20)   
--------------------

Argumentos de entrada

contraer todo

`robot` — Modelo de robot
objeto `RigidBodyTree`

Modelo de robot, especificado como un objeto rigidBodyTree.

`bodyname` — Nombre del cuerpo principal
escalar de cadena | vector de caracteres

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

`subtreerobot` — Modelo de robot de subárbol
objeto `rigidBodyTree`

Modelo de robot de subárbol, especificado como un objeto rigidBodyTree.

`ReplaceBase` — Reemplazar la base del subárbol actual
`true` (predeterminado) | `false`

Reemplaza la base actual del subárbol por bodyname cuando MODE se especifica como true. El valor predeterminado de MODE se establece en true.

Tipos de datos: logical

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

expandir todo

R2022b: Argumento nombre-valor `ReplaceBase`

Use el argumento nombre-valor ReplaceBase para reemplazar la base actual del subárbol por bodyname.

Consulte también

rigidBodyJoint | rigidBody | addBody | removeBody | replaceBody