Así se programa el robot NAO para evitar colisiones

Compartelo

Python es un lenguaje de programación imprescindible para principiantes. Python es fácil y divertido de aprender, y muy recomendable para empezar por sus amplias capacidades. Gracias a su simplicidad, Python genera confianza e interés en el alumno, lo que siempre es bueno para animarle a continuar con su formación en otros lenguajes más austeros. Su código es fácil de leer y también ayuda a desarrollar un estilo de programación limpio sin necesidad de ser muy estricto con la sintaxis. Además, si quieres iniciarte en el mundo de la Robótica con plataformas como Raspberry Pi, el Big Data e incluso la Inteligencia Artificial (IA), Python es la mejor elección.

Por tanto, Python es un lenguaje que está creciendo rápidamente debido a su aplicación directa a la robótica o al Big Data. Por ello, sus programadores son de los mejores pagados en el sector, como puedes observar en nuestra Introducción a la Programación – Qué lenguaje de programación elegir..

No es por ello de extrañar que Python sea el lenguaje de programación favorito a la hora de programar robots, no solo por la amplia librería de módulos que posee sino también porque forma parte de la cultura del software libre y de compartir los desarrollos propios con el resto de la comunidad de programadores.

Si estás interesado en aprender Python, puedes apuntarte a nuestro CURSO ONLINE DE PYTHON y que  consta de más de 400 páginas de texto y más de 10 horas de video, con decenas de ejercicios que el alumno tendrá que resolver. Todo ello con la intención de conseguir el máximo dominio en el manejo del lenguaje. El curso también incluye numerosos vídeos explicativos del material presentado para aclarar aún más los conceptos. Además, se podrán organizar webinars en directo con vuestro profesor para aclarar en tiempo real las dudas que puedan surgir. Puedes encontrar un ejemplo del curso aquí.

Os adjuntamos a continuación el código PYTHON con el que se programa evitar que el robot NAO colisione con un obstáculo, a modo de ejemplo de programación:

# -*- encoding: UTF-8 -*-
''' Collision detection : arm collision detection '''
import argparse
import almath
import time
from naoqi import ALProxy

def moveArm(motionProxy, pTarget, pRobotName, pChainName):
    ''' Function to make NAO bump on his Torso or Head with his arm '''

    # Set the fraction of max speed for the arm movement.
    pMaxSpeedFraction = 0.5

    # Define the final position.
    if pTarget == "Torso":
        shoulderPitchAngle = 50
    elif pTarget == "Head":
        shoulderPitchAngle = -50
    else:
        print "ERROR: target is unknown"
        print "Must be Torso or Head"
        print "---------------------"
        exit(1)

    ShoulderRollAngle  = 6
    ElbowYawAngle      = 0
    ElbowRollAngle     = -150

    if pChainName == "LArm":
        pTargetAngles = [shoulderPitchAngle, +ShoulderRollAngle,
            +ElbowYawAngle, +ElbowRollAngle]
    elif pChainName == "RArm":
        pTargetAngles = [shoulderPitchAngle, -ShoulderRollAngle,
            -ElbowYawAngle, -ElbowRollAngle]
    else:
        print "ERROR: chainName is unknown"
        print "Must be LArm or RArm"
        print "---------------------"
        exit(1)

    # Set the target angles according to the robot version.
    if pRobotName == "naoH25" or\
       pRobotName == "naoAcademics" or\
       pRobotName == "naoT14":
        pTargetAngles += [0.0, 0.0]
    elif pRobotName == "naoH21":
        pass
    elif pRobotName == "naoT2":
        pTargetAngles = []
    else:
        print "ERROR: Your robot is unknown"
        print "This test is not available for your Robot"
        print "---------------------"
        exit(1)

    # Convert to radians.
    pTargetAngles = [x * almath.TO_RAD for x in pTargetAngles]

    # Move the arm to the final position.
    motionProxy.angleInterpolationWithSpeed(
        pChainName, pTargetAngles, pMaxSpeedFraction)


def main(robotIP, pChainName, PORT=9559):
    ''' Example showing the effect of collision detection
        Nao bumps his chest with his left arm with collision detection enabled
        or disabled.
    '''

    ##################
    # Initialization #
    ##################

    motionProxy  = ALProxy("ALMotion", robotIP, PORT)
    postureProxy = ALProxy("ALRobotPosture", robotIP, PORT)

    # Wake up robot
    motionProxy.wakeUp()

    # Send robot to Stand Init
    postureProxy.goToPosture("StandInit", 0.5)

    # Get the robot configuration.
    robotConfig = motionProxy.getRobotConfig()
    robotName = ""
    for i in range(len(robotConfig[0])):
        if (robotConfig[0][i] == "Model Type"):
            robotName = robotConfig[1][i]

    ###############################
    # Arm motion bumping on torso #
    ###############################

    # Disable collision detection on chainName.
    pEnable = False
    success = motionProxy.setCollisionProtectionEnabled(pChainName, pEnable)
    if (not success):
        print("Failed to disable collision protection")
    time.sleep(1.0)

    # Make NAO's arm move so that it bumps its torso.
    pTargetName = "Torso"
    moveArm(motionProxy, pTargetName, robotName, pChainName)
    time.sleep(1.0)

    # Go back to pose init.
    postureProxy.goToPosture("StandInit", 1.0)

    # Enable collision detection on chainName.
    pEnable = True
    success = motionProxy.setCollisionProtectionEnabled(pChainName, pEnable)
    if (not success):
        print("Failed to enable collision protection")
    time.sleep(1.0)

    # Make NAO's arm move and see that it does not bump on the torso.
    pTargetName = "Torso"
    moveArm(motionProxy, pTargetName, robotName, pChainName)

    ##############################
    # Arm motion bumping on head #
    ##############################

    time.sleep(1.0)
    # Go back to pose init.
    postureProxy.goToPosture("StandInit", 1.0)
    # Disable collision detection on chainName.
    pEnable = False
    success = motionProxy.setCollisionProtectionEnabled(pChainName, pEnable)
    if (not success):
        print("Failed to disable collision protection")
    time.sleep(1.0)
    # Make NAO's arm move so that it bumps its head.
    pTargetName = "Head"
    moveArm(motionProxy, pTargetName, robotName, pChainName)

    time.sleep(1.0)
    # Go back to pose init.
    postureProxy.goToPosture("StandInit", 1.0)
    # Enable collision detection on chainName.
    pEnable = True
    success = motionProxy.setCollisionProtectionEnabled(pChainName, pEnable)
    if (not success):
        print("Failed to enable collision protection")
    # Make NAO's arm move and see that it does not bump on the head.
    pTargetName = "Head"
    moveArm(motionProxy, pTargetName, robotName, pChainName)

    time.sleep(1.0)
    # Go back to pose init.
    postureProxy.goToPosture("StandInit", 1.0)

    # Go to rest position
    motionProxy.rest()

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot ip address")
    parser.add_argument("--port", type=int, default=9559,
                        help="Robot port number")
    parser.add_argument("--chain", type=str, default="LArm",
                        choices=["LArm", "RArm"], help="Chain name")

    args = parser.parse_args()
    main(args.ip, args.chain, args.port)

Compartelo
Sobre ROBOTechnics 81 Artículos
Robotica educativa y programacion

Sé el primero en comentar

Dejar una contestacion

Tu dirección de correo electrónico no será publicada.


*