General tools API

NAOqi Motion - Overview | API

---

Method list

class ALMotionProxy

• ALMotionProxy::areNotificationsEnabled
• ALMotionProxy::getBodyNames
• ALMotionProxy::getSensorNames
• ALMotionProxy::getLimits
• ALMotionProxy::getMotionCycleTime
• ALMotionProxy::getSummary
• ALMotionProxy::getMass
• ALMotionProxy::getCOM
• ALMotionProxy::getSupportPolygon
• ALMotionProxy::setMotionConfig
• ALMotionProxy::setEnableNotifications

Deprecated Methods

• ALMotionProxy::getJointNames (deprecated, use getBodyNames instead)
• ALMotionProxy::getRobotConfig

Methods

bool ALMotionProxy::areNotificationsEnabled()

Get notifications status. Return true if notifications are active.

Returns:Return true is notifications are active.

std::vector<std::string> ALMotionProxy::getBodyNames(const std::string& name)

Gets the names of all the joints in the collection.

Parameters:

• name – Name of a chain, “Body”, “Chains”, “JointActuators”, “Joints” or “Actuators”.

Returns:

Vector of strings, one for each joint in the collection

almotion_getbodynames.cpp

#include <iostream>
#include <alproxies/almotionproxy.h>

int main(int argc, char **argv)
{
  std::string robotIp = "127.0.0.1";

  if (argc < 2) {
    std::cerr << "Usage: almotion_getbodynames robotIp "
              << "(optional default \"127.0.0.1\")."<< std::endl;
  }
  else {
    robotIp = argv[1];
  }

  AL::ALMotionProxy motion(robotIp);

  // Example showing how to get the names of all the joints in the body.
  std::vector<std::string> bodyNames = motion.getBodyNames("Body");
  std::cout << "All joints in Body: " << std::endl;
  std::cout << bodyNames << std::endl;

  // Example showing how to get the names of all the joints in the left leg.
  std::vector<std::string> leftLegJointNames = motion.getBodyNames("LLeg");
  std::cout << "All joints in LLeg: " << std::endl;
  std::cout << leftLegJointNames << std::endl;

  return 0;
}

almotion_getBodyNames.py

#! /usr/bin/env python
# -*- encoding: UTF-8 -*-

"""Example: Use getBodyNames Method"""

import qi
import argparse
import sys


def main(session):
    """
    This example uses the getBodyNames method.
    """
    # Get the service ALMotion.

    motion_service  = session.service("ALMotion")

    # Example showing how to get the names of all the joints in the body.
    bodyNames = motion_service.getBodyNames("Body")
    print "Body:"
    print str(bodyNames)
    print ""

    # Example showing how to get the names of all the joints in the left arm.
    leftArmJointNames = motion_service.getBodyNames("LArm")
    print "LArm:"
    print str(leftArmJointNames)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
    parser.add_argument("--port", type=int, default=9559,
                        help="Naoqi port number")

    args = parser.parse_args()
    session = qi.Session()
    try:
        session.connect("tcp://" + args.ip + ":" + str(args.port))
    except RuntimeError:
        print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
               "Please check your script arguments. Run with -h option for help.")
        sys.exit(1)
    main(session)

std::vector<std::string> ALMotionProxy::getJointNames(const std::string& name)

Deprecated since version 1.14: use ALMotionProxy::getBodyNames instead.

param name:Name of a chain, “Body”, “Chains”, “JointActuators”, “Joints” or “Actuators”. return:Vector of strings, one for each joint in the collection

std::vector<std::string> ALMotionProxy::getSensorNames()

Gets the list of sensors supported on your robot.

Returns:Vector of sensor names

almotion_getsensornames.cpp

#include <iostream>
#include <alproxies/almotionproxy.h>

int main(int argc, char **argv)
{
  std::string robotIp = "127.0.0.1";

  if (argc < 2) {
    std::cerr << "Usage: almotion_getsensornames robotIp "
              << "(optional default \"127.0.0.1\")."<< std::endl;
  }
  else {
    robotIp = argv[1];
  }

  AL::ALMotionProxy motion(robotIp);

  // Gets the list of sensors supported on your robot.
  std::vector<std::string> sensorList = motion.getSensorNames();
  std::cout << "Sensors: " << std::endl;
  for (unsigned int i=0; i<sensorList.size(); i++)
  {
     std::cout << sensorList.at(i) << std::endl;
  }

  return 0;
}

almotion_getSensorNames.py

#! /usr/bin/env python
# -*- encoding: UTF-8 -*-

"""Example: Use getSensorNames Method"""

import qi
import argparse
import sys


def main(session):
    """
    This example uses the getSensorNames method.
    """
    # Get the service ALMotion.

    motion_service  = session.service("ALMotion")

    # Example showing how to get the list of the sensors
    sensorList = motion_service.getSensorNames()
    for sensor in sensorList:
        print sensor


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
    parser.add_argument("--port", type=int, default=9559,
                        help="Naoqi port number")

    args = parser.parse_args()
    session = qi.Session()
    try:
        session.connect("tcp://" + args.ip + ":" + str(args.port))
    except RuntimeError:
        print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
               "Please check your script arguments. Run with -h option for help.")
        sys.exit(1)
    main(session)

AL::ALValue ALMotionProxy::getLimits(const std::string& name)

Get the minAngle (rad), maxAngle (rad), maxVelocity (rad.s-1) and maxTorque (N.m). for a given joint or actuator in the body.

Parameters:

• name – Name of a joint, chain, “Body”, “JointActuators”, “Joints” or “Actuators”.

Returns:

Array of ALValue arrays containing the minAngle, maxAngle, maxVelocity and maxTorque for all the joints specified.

almotion_getlimits.cpp

#include <iostream>
#include <alproxies/almotionproxy.h>

int main(int argc, char **argv)
{
  std::string robotIp = "127.0.0.1";

  if (argc < 2) {
    std::cerr << "Usage: almotion_getlimits robotIp "
              << "(optional default \"127.0.0.1\")."<< std::endl;
  }
  else {
    robotIp = argv[1];
  }

  AL::ALMotionProxy motion(robotIp);

  // Example showing how to get the limits for the whole body
  std::string name = "Body";
  std::vector<std::string> jointNames = motion.getBodyNames(name);
  AL::ALValue limits = motion.getLimits(name);
  for (unsigned int i=0; i<limits.getSize(); i++)
  {
    std::cout << " Joint name " << jointNames[i]
              << " minAngle " << limits[i][0] << " rad"
              << " maxAngle " << limits[i][1] << " rad"
              << " maxChange " << limits[i][2] << " rad.s-1"
              << " maxTorque " << limits[i][3] << " N.m"
              << std::endl;
  }

  return 0;
}

almotion_getLimits.py

#! /usr/bin/env python
# -*- encoding: UTF-8 -*-

"""Example: Use getLimits Method"""

import qi
import argparse
import sys


def main(session):
    """
    This example uses the getLimits method.
    """
    # Get the service ALMotion.

    motion_service  = session.service("ALMotion")

    # Example showing how to get the limits for the whole body
    name = "Body"
    limits = motion_service.getLimits(name)
    jointNames = motion_service.getBodyNames(name)
    for i in range(0,len(limits)):
        print jointNames[i] + ":"
        print "minAngle", limits[i][0],\
            "maxAngle", limits[i][1],\
            "maxVelocity", limits[i][2],\
            "maxTorque", limits[i][3]


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
    parser.add_argument("--port", type=int, default=9559,
                        help="Naoqi port number")

    args = parser.parse_args()
    session = qi.Session()
    try:
        session.connect("tcp://" + args.ip + ":" + str(args.port))
    except RuntimeError:
        print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
               "Please check your script arguments. Run with -h option for help.")
        sys.exit(1)
    main(session)

AL::ALValue ALMotionProxy::getMotionCycleTime()

Get the motion cycle time in milliseconds.

Returns:ALValue containing the cycle time in milliseconds as an integer.

AL::ALValue ALMotionProxy::getRobotConfig()

Deprecated since version 2.4: use ALRobotModel instead.

Get the robot configuration.

return:ALValue arrays containing the robot parameter names and the robot parameter values.

std::string ALMotionProxy::getSummary()

Returns a string representation of the Model’s state

Returns:A formated string

almotion_getsummary.cpp

#include <iostream>
#include <alproxies/almotionproxy.h>

int main(int argc, char **argv)
{
  std::string robotIp = "127.0.0.1";

  if (argc < 2) {
    std::cerr << "Usage: almotion_getsummary robotIp "
              << "(optional default \"127.0.0.1\")."<< std::endl;
  }
  else {
    robotIp = argv[1];
  }

  AL::ALMotionProxy motion(robotIp);

  // Example showing how to get a summary of Nao's state
  std::cout << motion.getSummary() << std::endl;

  return 0;
}

almotion_getSummary.py

#! /usr/bin/env python
# -*- encoding: UTF-8 -*-

"""Example: Use getSummary Method"""

import qi
import argparse
import sys


def main(session):
    """
    This example uses the getSummary method.
    """
    # Get the service ALMotion.

    motion_service  = session.service("ALMotion")

    # Example showing how to get a summary of Nao's state
    print motion_service.getSummary()


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
    parser.add_argument("--port", type=int, default=9559,
                        help="Naoqi port number")

    args = parser.parse_args()
    session = qi.Session()
    try:
        session.connect("tcp://" + args.ip + ":" + str(args.port))
    except RuntimeError:
        print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
               "Please check your script arguments. Run with -h option for help.")
        sys.exit(1)
    main(session)

float ALMotionProxy::getMass(const std::string& pName)

Gets the mass of a joint, chain, “Body” or “Joints”.

Parameters:

• pName – name of the body which we want the mass. “Body”, “Joints” and “Com” give the total mass of the robot. For the chain, it gives the total mass of the chain.

Returns:

The mass in kg.

almotion_getmass.cpp

#include <iostream>
#include <alproxies/almotionproxy.h>

int main(int argc, char **argv)
{
  std::string robotIp = "127.0.0.1";

  if (argc < 2) {
    std::cerr << "Usage: almotion_getmass robotIp "
              << "(optional default \"127.0.0.1\")."<< std::endl;
  }
  else {
    robotIp = argv[1];
  }

  AL::ALMotionProxy motion(robotIp);

  // Example showing how to get the mass of "HeadYaw".
  std::string pName = "HeadYaw";
  float mass = motion.getMass(pName);

  std::cout << "Mass on " << pName << " is " << mass << std::endl;

  return 0;
}

almotion_getMass.py

#! /usr/bin/env python
# -*- encoding: UTF-8 -*-

"""Example: Use getMass Method"""

import qi
import argparse
import sys


def main(session):
    """
    This example uses the getMass method.
    """
    # Get the service ALMotion.

    motion_service  = session.service("ALMotion")

    # Example showing how to get the mass of "HeadYaw".
    pName = "HeadYaw"
    mass = motion_service.getMass(pName)
    print pName + " mass: " + str(mass)

    # Example showing how to get the mass of the "LArm" chain.
    pName = "LArm"
    print "LArm mass: ", motion_service.getMass(pName)

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
    parser.add_argument("--port", type=int, default=9559,
                        help="Naoqi port number")

    args = parser.parse_args()
    session = qi.Session()
    try:
        session.connect("tcp://" + args.ip + ":" + str(args.port))
    except RuntimeError:
        print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
               "Please check your script arguments. Run with -h option for help.")
        sys.exit(1)
    main(session)

std::vector<float> ALMotionProxy::getCOM(const std::string& pName, const int& pSpace, const bool& pUseSensorValues)

Gets the COM of a joint, chain, “Body” or “Joints”.

Parameters:

• pName – Name of the body which we want the mass. In chain name case, this function give the com of the chain.
• pSpace – Task space {FRAME_TORSO = 0, FRAME_WORLD = 1, FRAME_ROBOT = 2}.
• pUseSensorValues – If true, the sensor values will be used to determine the position.

Returns:

The COM position (meter).

almotion_getcom.cpp

#include <iostream>
#include <alproxies/almotionproxy.h>

int main(int argc, char **argv)
{
  std::string robotIp = "127.0.0.1";

  if (argc < 2) {
    std::cerr << "Usage: almotion_getcom robotIp "
              << "(optional default \"127.0.0.1\")."<< std::endl;
  }
  else {
    robotIp = argv[1];
  }

  AL::ALMotionProxy motion(robotIp);

  // Example showing how to get the COM of "HeadYaw".
  std::string pName = "HeadYaw";
  int pSpace = 0; // FRAME_TORSO
  bool pUseSensors = false;
  std::vector<float> pos = motion.getCOM(pName, pSpace, pUseSensors);

  std::cout << pName << " COM position: " << std::endl;
  std::cout << "x: " << pos[0] << "; y: " << pos[1] << "; z: " << pos[2]
            << std::endl;

  return 0;
}

almotion_getCOM.py

#! /usr/bin/env python
# -*- encoding: UTF-8 -*-

"""Example: Use getCOM Method"""

import qi
import argparse
import sys
import motion


def main(session):
    """
    This example uses the getCOM method.
    """
    # Get the service ALMotion.

    motion_service  = session.service("ALMotion")

    # Example showing how to get the COM position of "HeadYaw".
    name = "HeadYaw"
    frame = motion.FRAME_TORSO
    useSensors = False
    pos = motion_service.getCOM(name, frame, useSensors)
    print "HeadYaw COM Position: x = ", pos[0], " y:", pos[1], " z:", pos[2]


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
    parser.add_argument("--port", type=int, default=9559,
                        help="Naoqi port number")

    args = parser.parse_args()
    session = qi.Session()
    try:
        session.connect("tcp://" + args.ip + ":" + str(args.port))
    except RuntimeError:
        print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
               "Please check your script arguments. Run with -h option for help.")
        sys.exit(1)
    main(session)

std::vector<std::vector<float>> ALMotionProxy::getSupportPolygon(const int& pFrame, const bool& pUseSensorValues)

Gets the current support polygon of the robot.

Parameters:

• pFrame – Task frame. This API accepts the following values: {FRAME_WORLD = 1, FRAME_ROBOT = 2}.
• pUseSensorValues – If true, the sensor values will be used to determine the robot support polygon.

Returns:

A list of 2D points representing the convex support polygon of the robot.

almotion_printSupportPolygon.py

#! /usr/bin/env python
# -*- encoding: UTF-8 -*-

"""Example: Use getSupportPolygon Method"""

import qi
import argparse
import sys
import time
import pygame


# display settings
displayScale = 1000 # pixels/m
screenWidth = 700   # pixels
screenHeight = 700  # pixels

screenColor = pygame.Color("white")
polygonCommandColor = pygame.Color("green")
polygonSensorColor = pygame.Color("red")
comColor = pygame.Color("blue")

def almotionToPygame(point):
    """
    Links ALMotion to Pygame.
    """
    return [int(-point[1] * displayScale + 0.5 * screenWidth),
            int(-point[0] * displayScale + 0.5 * screenHeight)]

def drawPolygon(screen, data, color) :
    """
    Draw a Polygon.
    """
    if (data != []):
        pygame.draw.lines(screen, color, True, map(almotionToPygame, data), 1)

def drawPoint(screen, point, color) :
    """
    Draw a Point.
    """
    pygame.draw.circle(screen, color, almotionToPygame(point), 3)

def main(session, frame) :
    """
    This example uses the getSupportPolygon method.
    """
    # Get the service ALMotion.

    motion_service  = session.service("ALMotion")

    pygame.init()
    screen = pygame.display.set_mode((screenWidth, screenHeight))
    pygame.display.set_caption("Robot Support Polygon")

    running = True
    while (running):
        # Check if user has clicked 'close'
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        screen.fill(screenColor)

        supportPolygonCommand = motion_service.getSupportPolygon(frame, False)
        drawPolygon(screen, supportPolygonCommand, polygonCommandColor)

        supportPolygonSensor = motion_service.getSupportPolygon(frame, True)
        drawPolygon(screen, supportPolygonSensor, polygonSensorColor)

        com = motion_service.getCOM("Body", frame, False)
        drawPoint(screen, com, comColor)

        pygame.display.flip()
        time.sleep(0.1)
    pygame.quit()


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip", type=str, default="127.0.0.1",
                        help="Robot IP address. On robot or Local Naoqi: use '127.0.0.1'.")
    parser.add_argument("--port", type=int, default=9559,
                        help="Naoqi port number")
    parser.add_argument("--frame", type=str, choices =['world', 'robot'], default = 'world')

    args = parser.parse_args()
    session = qi.Session()
    try:
        session.connect("tcp://" + args.ip + ":" + str(args.port))
    except RuntimeError:
        print ("Can't connect to Naoqi at ip \"" + args.ip + "\" on port " + str(args.port) +".\n"
               "Please check your script arguments. Run with -h option for help.")
        sys.exit(1)
    if (args.frame == 'world'):
        frame = 1
    else:
        frame = 2
    main(session, frame)

void ALMotionProxy::setMotionConfig(const AL::ALValue& config)

Internal Use.

Parameters:

• config – Internal: An array of ALValues [i][0]: name, [i][1]: value

void ALMotionProxy::setEnableNotifications(bool enable)

Enable / Disable notifications.

Parameters:

• enable – If true enable notifications.