Construir modelos de árbol de cuerpo rígido básicos

Abrir script en vivo

En este ejemplo se muestra cómo utilizar los elementos del modelo de robot de árbol de cuerpo rígido para construir un brazo robótico básico con cinco grados de libertad. El modelo creado en este ejemplo representa unos brazos robóticos de mesa comunes construidos con servos y una placa de circuito integrado.

Para cargar un modelo de robot a partir de un conjunto de robots comunes disponibles en el mercado, utilice la función loadrobot. Para ver un ejemplo, consulte Cargar modelos de robot predefinidos.

Si tiene un archivo URDF o un modelo de Simscape Multibody™ del robot, puede importarlo como un árbol de cuerpo rígido mediante importrobot. Para ver un ejemplo, consulte Importar un robot desde un archivo URDF.

Crear elementos de cuerpo rígido

En primer lugar, cree un modelo de robot rigidBodyTree. El modelo de robot de árbol de cuerpo rígido representa el robot completo, que está formado por cuerpos rígidos y articulaciones que los unen. La base del robot es un marco fijo que define las coordenadas del mundo real. Al añadir el primer cuerpo, se fija el cuerpo a la base.

robot = rigidBodyTree("DataFormat","column");
base = robot.Base;

Luego, cree una serie de enlaces como objetos rigidBody. El robot consta de una base giratoria, 3 brazos rectangulares y una pinza.

rotatingBase = rigidBody("rotating_base");
arm1 = rigidBody("arm1");
arm2 = rigidBody("arm2");
arm3 = rigidBody("arm3");
gripper = rigidBody("gripper");

Cree objetos de colisión para cada cuerpo rígido con diferentes formas y dimensiones. Al crear los objetos de colisión, el marco de coordenadas se centra de forma predeterminada en el centro del objeto. Establezca la propiedad Pose para mover el marco a la parte inferior de cada cuerpo a lo largo del eje z. Modele la pinza como una esfera para mayor simplicidad.

collBase = collisionCylinder(0.05,0.04); % cylinder: radius,length
collBase.Pose = trvec2tform([0 0 0.04/2]);
coll1 = collisionBox(0.01,0.02,0.15); % box: length, width, height (x,y,z)
coll1.Pose = trvec2tform([0 0 0.15/2]);
coll2 = collisionBox(0.01,0.02,0.15); % box: length, width, height (x,y,z)
coll2.Pose = trvec2tform([0 0 0.15/2]);
coll3 = collisionBox(0.01,0.02,0.15); % box: length, width, height (x,y,z)
coll3.Pose = trvec2tform([0 0 0.15/2]);
collGripper = collisionSphere(0.025); % sphere: radius
collGripper.Pose = trvec2tform([0 -0.015 0.025/2]);

Añada los cuerpos de colisión a los objetos de cuerpo rígido.

addCollision(rotatingBase,collBase)
addCollision(arm1,coll1)
addCollision(arm2,coll2)
addCollision(arm3,coll3)
addCollision(gripper,collGripper)

Fijar las articulaciones

Cada cuerpo rígido se acopla mediante una articulación rotativa. Cree los objetos rigidBodyJoint para cada cuerpo. Especifique el eje x como eje de rotación para las articulaciones del brazo rectangular. Especifique el eje y de la pinza. El eje predeterminado es el eje z.

jntBase = rigidBodyJoint("base_joint","revolute");
jnt1 = rigidBodyJoint("jnt1","revolute");
jnt2 = rigidBodyJoint("jnt2","revolute");
jnt3 = rigidBodyJoint("jnt3","revolute");
jntGripper = rigidBodyJoint("gripper_joint","revolute");

jnt1.JointAxis = [1 0 0]; % x-axis
jnt2.JointAxis = [1 0 0];
jnt3.JointAxis = [1 0 0];
jntGripper.JointAxis = [0 1 0] % y-axis

jntGripper = 
  rigidBodyJoint with properties:

                      Type: 'revolute'
                      Name: 'gripper_joint'
                 JointAxis: [0 1 0]
            PositionLimits: [-3.1416 3.1416]
              HomePosition: 0
    JointToParentTransform: [4x4 double]
     ChildToJointTransform: [4x4 double]

Establezca las transformaciones del acoplamiento de las articulaciones entre los cuerpos. Cada transformación se basa en las dimensiones de la longitud del cuerpo rígido anterior (eje z). Desplace las articulaciones del brazo en el eje x para evitar colisiones durante la rotación.

setFixedTransform(jnt1,trvec2tform([0.015 0 0.04]))
setFixedTransform(jnt2,trvec2tform([-0.015 0 0.15]))
setFixedTransform(jnt3,trvec2tform([0.015 0 0.15]))
setFixedTransform(jntGripper,trvec2tform([0 0 0.15]))

Ensamblar el robot

Cree un arreglo de objetos para los cuerpos y las articulaciones, incluida la base original. Añada cada articulación al cuerpo y después añada el cuerpo al árbol. Visualice cada paso.

bodies = {base,rotatingBase,arm1,arm2,arm3,gripper};
joints = {[],jntBase,jnt1,jnt2,jnt3,jntGripper};

figure("Name","Assemble Robot","Visible","on")
for i = 2:length(bodies) % Skip base. Iterate through adding bodies and joints.
            bodies{i}.Joint = joints{i};
            addBody(robot,bodies{i},bodies{i-1}.Name)
            show(robot,"Collisions","on","Frames","off");
            drawnow;
end

Llame a la función showdetails para ver una lista de la información final del árbol. Asegúrese de que la relación principal-secundario y los tipos de articulación sean correctos.

showdetails(robot)

--------------------
Robot: (5 bodies)

 Idx            Body Name           Joint Name           Joint Type            Parent Name(Idx)   Children Name(s)
 ---            ---------           ----------           ----------            ----------------   ----------------
   1        rotating_base           base_joint             revolute                     base(0)   arm1(2)  
   2                 arm1                 jnt1             revolute            rotating_base(1)   arm2(3)  
   3                 arm2                 jnt2             revolute                     arm1(2)   arm3(4)  
   4                 arm3                 jnt3             revolute                     arm2(3)   gripper(5)  
   5              gripper        gripper_joint             revolute                     arm3(4)   
--------------------

Interactuar con el modelo de robot

Visualice el modelo de robot para confirmar las dimensiones mediante el objeto interactiveRigidBodyTree. Utilice la interfaz gráfica interactiva para mover el modelo. Puede seleccionar cuerpos específicos y establecer la posición de sus articulaciones. Para interactuar con modelos más detallados proporcionados con Robotics System Toolbox™, consulte Cargar modelos de robot predefinidos o la función loadrobot.

figure("Name","Interactive GUI")
gui = interactiveRigidBodyTree(robot,"MarkerScaleFactor",0.25);

Mueva el marcador interactivo para probar las distintas posiciones deseadas de las pinzas. La interfaz gráfica utiliza la cinemática inversa para generar la mejor configuración de las articulaciones. Para obtener más información sobre la interfaz gráfica interactiva, consulte el objeto interactiveRigidBodyTree.

Siguientes pasos

Con el modelo creado en MATLAB®, podrá hacer varias cosas distintas.

Calcule Cinemática inversa para obtener configuraciones de articulaciones basadas en las posiciones deseadas del efector final. Además de los parámetros del modelo del robot, especifique otras restricciones, como apuntamiento, límites cartesianos o poses objetivo.
Genere Generación de trayectorias basadas en waypoints y en otros parámetros con perfiles de velocidad trapezoidal, B-splines o trayectorias polinómicas.
Realice Planificación de manipuladores mediante los modelos de robot y el planificador de rutas de árboles aleatorios de exploración rápida (RRT).
Compruebe si se producen Detección de colisiones con obstáculos del entorno para garantizar que el robot se mueve de forma segura y eficaz.