# SoftBank Robotics documentation What's new in NAOqi 2.8?

# Locomotion control API

NAOqi Motion - Overview | API | robot position Tutorial

## Method list

class `ALMotionProxy`

- `ALMotionProxy::move`
- `ALMotionProxy::moveToward`
- `ALMotionProxy::moveTo`
- `ALMotionProxy::setFootSteps`
- `ALMotionProxy::setFootStepsWithSpeed`
- `ALMotionProxy::getFootSteps`
- `ALMotionProxy::moveInit`
- `ALMotionProxy::waitUntilMoveIsFinished`
- `ALMotionProxy::moveIsActive`
- `ALMotionProxy::stopMove`
- `ALMotionProxy::getMoveConfig`
- `ALMotionProxy::getRobotPosition`
- `ALMotionProxy::getNextRobotPosition`
- `ALMotionProxy::getRobotVelocity`
- `ALMotionProxy::getMoveArmsEnabled`
- `ALMotionProxy::setMoveArmsEnabled`

Deprecated Methods

- `ALMotionProxy::setWalkTargetVelocity` (deprecated, use moveToward instead)
- `ALMotionProxy::walkTo` (deprecated, use moveTo instead)
- `ALMotionProxy::walkInit` (deprecated, use moveInit instead)
- `ALMotionProxy::waitUntilWalkIsFinished` (deprecated, use waitUntilMoveIsFinished instead)
- `ALMotionProxy::walkIsActive` (deprecated, use moveIsActive instead)
- `ALMotionProxy::stopWalk` (deprecated, use stopMove instead)
- `ALMotionProxy::getFootGaitConfig` (deprecated, use getMoveConfig instead)
- `ALMotionProxy::getWalkArmsEnabled` (deprecated, use getMoveArmsEnabled instead)
- `ALMotionProxy::setWalkArmsEnabled` (deprecated, use setMoveArmsEnabled instead)

## Methods

void `ALMotionProxy::``move`(const float& x, const float& y, const float& theta)

  There are two overloads of this function:

  - ALMotionProxy::move
  - ALMotionProxy::move with move configuration

  Makes the robot move at the given velocity, expressed in FRAME_ROBOT. This is a non-blocking call.

  Parameters: | x – velocity along X-axis, in meters per second. Use negative values for backward motion y – velocity along Y-axis, in meters per second. Use positive values to go to the left theta – velocity around Z-axis, in radians per second. Use negative values to turn clockwise.

void `ALMotionProxy::``move`(const float& x, const float& y, const float& theta, const AL::ALValue moveConfig)

  Makes the robot move at the given velocity, expressed in FRAME_ROBOT, with a move configuration. This is a non-blocking call.

  Parameters: | x – velocity along X-axis, in meters per second. Use negative values for backward motion y – velocity along Y-axis, in meters per second. Use positive values to go to the left theta – velocity around Z-axis, in radians per second. Use negative values to turn clockwise. moveConfig – An ALValue with the custom move configuration. For further details, see: Move config.

void `ALMotionProxy::``moveToward`(const float& x, const float& y, const float& theta)

  There are two overloads of this function:

  - ALMotionProxy::moveToward
  - ALMotionProxy::moveToward with move configuration

  Makes the robot move at the given normalized velocity, expressed in FRAME_ROBOT. This is a non-blocking call.

  Parameters: | x – normalized, unitless, velocity along X-axis. +1 and -1 correspond to the maximum velocity in the forward and backward directions, respectively. y – normalized, unitless, velocity along Y-axis. +1 and -1 correspond to the maximum velocity in the left and right directions, respectively. theta – normalized, unitless, velocity around Z-axis. +1 and -1 correspond to the maximum velocity in the counterclockwise and clockwise directions, respectively.

void `ALMotionProxy::``moveToward`(const float& x, const float& y, const float& theta, const AL::ALValue moveConfig)

  Makes the robot move at the given normalized velocity, expressed in FRAME_ROBOT, with a move configuration. This is a non-blocking call.

  Parameters: | x – normalized, unitless, velocity along X-axis. +1 and -1 correspond to the maximum velocity in the forward and backward directions, respectively. y – normalized, unitless, velocity along Y-axis. +1 and -1 correspond to the maximum velocity in the left and right directions, respectively. theta – normalized, unitless, velocity around Z-axis. +1 and -1 correspond to the maximum velocity in the counterclockwise and clockwise directions, respectively. moveConfig – An ALValue with the custom move configuration. For further details, see: Move config.

  `almotion_moveToward.py`

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

      """Example: Use moveToward Method"""

      import qi
      import argparse
      import sys
      import time

      def main(session):
          """
          This example uses the moveToward method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # Example showing the use of moveToward
          # The parameters are fractions of the maximums
          # Here we are asking for full speed forwards
          x     = 1.0
          y     = 0.0
          theta = 0.0
          frequency = 1.0
          motion_service.moveToward(x, y, theta, [["Frequency", frequency]])

          # If we don't send another command, he will move forever
          # Lets make him slow down(step length) and turn after 3 seconds
          time.sleep(3)
          x     = 0.5
          theta = 0.6
          motion_service.moveToward(x, y, theta, [["Frequency", frequency]])

          # Lets make him slow down(frequency) after 3 seconds
          time.sleep(3)
          frequency = 0.5
          motion_service.moveToward(x, y, theta, [["Frequency", frequency]])

          # Lets make him stop after 3 seconds
          time.sleep(3)
          motion_service.stopMove()
          # Note that at any time, you can use a moveTo command
          # to run a precise distance. The last command received,
          # of velocity or position always wins

          # Go to rest position
          motion_service.rest()

      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)

void `ALMotionProxy::``setWalkTargetVelocity`(const float& x, const float& y, const float& theta, const float& frequency)

  Deprecated since version 1.22: use `ALMotionProxy::moveToward` instead. Note that ‘frequency’ parameter is now set using ‘MaxStepFrequency’ inside Move config parameter.

  NAO only

  There are three overloads of this function:

  - ALMotionProxy::setWalkTargetVelocity
  - ALMotionProxy::setWalkTargetVelocity with feetGaitConfiguration
  - ALMotionProxy::setWalkTargetVelocity with leftFootGaitConfig and rightFootGaitConfig

  Makes the robot walk at the given velocity. This is a non-blocking call.

  Parameters: | x – Fraction of MaxStepX. Use negative for backwards. [-1.0 to 1.0] y – Fraction of MaxStepY. Use negative for right. [-1.0 to 1.0] theta – Fraction of MaxStepTheta. Use negative for clockwise [-1.0 to 1.0] frequency – Fraction of MaxStepFrequency [0.0 to 1.0]

void `ALMotionProxy::``setWalkTargetVelocity`(const float& x, const float& y, const float& theta, const float& frequency, const AL::ALValue& feetGaitConfig)

  Deprecated since version 1.22: use `ALMotionProxy::moveToward` instead. Note that ‘frequency’ parameter is now set using ‘MaxStepFrequency’ inside Move config parameter.

  NAO only

  Makes the robot walk at the given velocity. This is a non-blocking call.

  Parameters: | x – Fraction of MaxStepX. Use negative for backwards. [-1.0 to 1.0] y – Fraction of MaxStepY. Use negative for right. [-1.0 to 1.0] theta – Fraction of MaxStepTheta. Use negative for clockwise [-1.0 to 1.0] frequency – Fraction of MaxStepFrequency [0.0 to 1.0] feetGaitConfig – An ALValue with the custom gait configuration for both feet

void `ALMotionProxy::``setWalkTargetVelocity`(const float& x, const float& y, const float& theta, const float& frequency, const AL::ALValue& leftFootGaitConfig, const AL::ALValue& rightFootGaitConfig)

  Deprecated since version 1.22: use `ALMotionProxy::moveToward` instead. Note that ‘frequency’ parameter is now set using ‘MaxStepFrequency’ inside Move config parameter.

  NAO only

  Makes the robot walk at the given velocity. This is a non-blocking call.

  Parameters: | x – Fraction of MaxStepX. Use negative for backwards. [-1.0 to 1.0] y – Fraction of MaxStepY. Use negative for right. [-1.0 to 1.0] theta – Fraction of MaxStepTheta. Use negative for clockwise [-1.0 to 1.0] frequency – Fraction of MaxStepFrequency [0.0 to 1.0] leftFootGaitConfig – An ALValue with custom gait configuration for the left foot rightFootGaitConfig – An ALValue with custom gait configuration for the right foot

bool `ALMotionProxy::``moveTo`(const float& x, const float& y, const float& theta)

  There are four overloads of this function:

  - ALMotionProxy::moveTo
  - ALMotionProxy::moveTo with move configuration
  - ALMotionProxy::moveTo with controlPoints, NAO only
  - ALMotionProxy::moveTo with controlPoints and move configuration, NAO only
  - ALMotionProxy::moveTo time constrained version, Pepper only

  Makes the robot move to the given pose in the ground plane, relative to FRAME_ROBOT. This is a blocking call.

  Parameters: | x – Distance along the X axis in meters. y – Distance along the Y axis in meters. theta – Rotation around the Z axis in radians [-3.1415 to 3.1415].
  Returns: | True if the moveTo terminated successfully, False if it was interrupted.

  `almotion_moveto.cpp`

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

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

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

        AL::ALMotionProxy motion(robotIp);
        AL::ALRobotPostureProxy robotPosture(robotIp);

        robotPosture.goToPosture("StandInit", 0.5f);

        // Example showing the moveTo command
        // as length of path is less than 0.4m
        // the path will be an SE3 interpolation
        // The units for this command are meters and radians
        float x  = 0.2f;
        float y  = 0.2f;
        // pi/2 anti-clockwise (90 degrees)
        float theta = 1.5709f;
        motion.moveTo(x, y, theta);
        // Will block until walk Task is finished

        // Example showing the moveTo command
        // as length of path is more than 0.4m
        // the path will be follow a dubins curve
        // The units for this command are meters and radians
        x  = -0.1f;
        y  = -0.5f;
        theta  = 0.0f;
        motion.moveTo(x, y, theta);

        return 0;
      }

  `almotion_moveTo.py`

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

      """Example: Use moveTo Method"""

      import qi
      import argparse
      import sys
      import math

      def main(session):
          """
          This example uses the moveTo method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # Example showing the moveTo command
          # The units for this command are meters and radians
          x  = 0.2
          y  = 0.2
          theta  = math.pi/2
          motion_service.moveTo(x, y, theta)
          # Will block until move Task is finished

          ########
          # NOTE #
          ########
          # If moveTo() method does nothing on the robot,
          # read the section about walk protection in the
          # Locomotion control overview page.

          # Go to rest position
          motion_service.rest()

      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)

bool `ALMotionProxy::``moveTo`(const float& x, const float& y, const float& theta, const AL::ALValue& moveConfig)

  Makes the robot move to the given pose in the ground plane, relative to FRAME_ROBOT, with custom move configuration. This is a blocking call.

  Parameters: | x – Distance along the X axis in meters. y – Distance along the Y axis in meters. theta – Rotation around the Z axis in radians [-3.1415 to 3.1415]. moveConfig – An ALValue with the custom move configuration. For further details, see: Move config.
  Returns: | True if the moveTo terminated successfully, False if it was interrupted.

void `ALMotionProxy::``moveTo`(const AL::ALValue& controlPoints)

  NAO only - For Pepper, use Planar Move.

  Makes the robot move to the given pose in the ground plane, relative to FRAME_ROBOT, while passing through check points. This is a blocking call.

  Parameters: | controlPoint – An ALValue with all the control points [[x1,y1,theta1], ..., [xN,yN,thetaN]
  Returns: | True if the moveTo terminated successfully, False if it was interrupted.

bool `ALMotionProxy::``moveTo`(const AL::ALValue& controlPoints, const AL::ALValue& moveConfig)

  NAO only - For Pepper, use Planar Move.

  Makes the robot move to the given pose in the ground plane, relative to FRAME_ROBOT, while passing through check points with custom move configuration. This is a blocking call.

  Parameters: | controlPoints – An ALValue with all the control points [[x1,y1,theta1], ..., [xN,yN,thetaN] moveConfig – An ALValue with the custom move configuration. For further details, see: Move config.
  Returns: | True if the moveTo terminated successfully, False if it was interrupted.

bool `ALMotionProxy::``moveTo`(const float& x, const float& y, const float& theta, const float& time)

  Pepper only

  Makes the robot move to the relative position (x, y, theta) in time.

  If time is too short, the robot will move to (x, y, theta) in optimal time (> time), and NAOqi will warn the user that input time is not achievable.

  Parameters: | x – Distance along the X axis in meters. y – Distance along the Y axis in meters. theta – Rotation around the Z axis in radians [-3.1415 to 3.1415]. time – The time to reach the target position in seconds.
  Returns: | True if the moveTo terminated successfully, False if it was interrupted.

bool `ALMotionProxy::``walkTo`(const float& x, const float& y, const float& theta)

  Deprecated since version 1.14: use `ALMotionProxy::moveTo` instead.

  - ALMotionProxy::walkTo
  - ALMotionProxy::walkTo with feetGaitConfig
  - ALMotionProxy::walkTo with controlPoints
  - ALMotionProxy::walkTo with controlPoints and feetGaitConfig

  Makes the robot walk to the given pose in the ground plane, relative to FRAME_ROBOT. This is a blocking call.

  Parameters: | x – Distance along the X axis in meters. y – Distance along the Y axis in meters. theta – Rotation around the Z axis in radians [-3.1415 to 3.1415].
  Returns: | True if the walkTo terminated successfully, False if it was interrupted.

bool `ALMotionProxy::``walkTo`(const float& x, const float& y, const float& theta, const AL::ALValue& feetGaitConfig)

  Deprecated since version 1.14: use `ALMotionProxy::moveTo` instead.

  Makes the robot move to the given pose in the ground plane, relative to FRAME_ROBOT, with custom gait parameters. This is a blocking call.

  Parameters: | x – Distance along the X axis in meters. y – Distance along the Y axis in meters. theta – Rotation around the Z axis in radians [-3.1415 to 3.1415]. feetGaitConfig – An ALValue with the custom gait configuration for both feet.
  Returns: | True if the walkTo terminated successfully, False if it was interrupted.

bool `ALMotionProxy::``walkTo`(const AL::ALValue& controlPoints)

  Deprecated since version 1.14: use `ALMotionProxy::moveTo` instead.

  Makes the robot move to the given pose in the ground plane, relative to FRAME_ROBOT, while passing through check points. This is a blocking call.

  Parameters: | controlPoints – An ALValue with all the control points [[x1,y1,theta1], ..., [xN,yN,thetaN]
  Returns: | True if the walkTo terminated successfully, False if it was interrupted.

bool `ALMotionProxy::``walkTo`(const AL::ALValue& controlPoints, const AL::ALValue& feetGaitConfig)

  Deprecated since version 1.14: use `ALMotionProxy::moveTo` instead.

  Makes the robot walk to the given pose in the ground plane, relative to FRAME_ROBOT, while passing through check points with custom move configuration. This is a blocking call.

  Parameters: | controlPoints – An ALValue with all the control points [[x1,y1,theta1], ..., [xN,yN,thetaN] feetGaitConfig – An ALValue with the custom gait configuration for both feet
  Returns: | True if the walkTo terminated successfully, False if it was interrupted.

void `ALMotionProxy::``setFootSteps`(const std::vector<std::string>& legName, const AL::ALValue& footSteps, const std::vector<float>& timeList, const bool& clearExisting)

  NAO only

  Makes the robot do foot step planner. This is a non-blocking call.

  Parameters: | legName – name of the leg to move(‘LLeg’or ‘RLeg’) footSteps – [x, y, theta], [Position along X/Y, Orientation round Z axis] of the leg relative to the other Leg in [meters, meters, radians]. Must be less than [MaxStepX, MaxStepY, MaxStepTheta] timeList – time list of each foot step clearExisting – Clear existing foot steps.

  `almotion_setFootSteps.py`

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

      """Example: Use setFootSteps Method"""

      import qi
      import argparse
      import sys
      import time

      def main(session):
          """
          This example uses the setFootSteps method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # A small step forwards and anti-clockwise with the left foot
          legName  = ["LLeg"]
          X        = 0.04
          Y        = 0.1
          Theta    = 0.3
          footSteps = [[X, Y, Theta]]
          timeList = [0.6]
          clearExisting = False
          motion_service.setFootSteps(legName, footSteps, timeList, clearExisting)

          time.sleep(1.0)

          # A small step forwards and anti-clockwise with the left foot
          legName = ["LLeg", "RLeg"]
          X       = 0.04
          Y       = 0.1
          Theta   = 0.3
          footSteps = [[X, Y, Theta], [X, -Y, Theta]]
          timeList = [0.6, 1.2]
          clearExisting = False
          motion_service.setFootSteps(legName, footSteps, timeList, clearExisting)

          motion_service.waitUntilMoveIsFinished()

          # Go to rest position
          motion_service.rest()

      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)

void `ALMotionProxy::``setFootStepsWithSpeed`(const std::vector<std::string>& legName, const AL::ALValue& footSteps, const std::vector<float>& fractionMaxSpeed, const bool& clearExisting)

  NAO only

  Makes the robot do foot step planner with speed. This is a blocking call.

  Parameters: | legName – name of the leg to move(‘LLeg’or ‘RLeg’) footSteps – [x, y, theta], [Position along X/Y, Orientation round Z axis] of the leg relative to the other Leg in [meters, meters, radians]. Must be less than [MaxStepX, MaxStepY, MaxStepTheta] fractionMaxSpeed – speed of each foot step. Must be between 0 and 1. clearExisting – Clear existing foot steps.

  `almotion_setFootStepsWithSpeed.py`

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

      """Example: Use setFootStepsWithSpeed Method"""

      import qi
      import argparse
      import sys
      import time

      def main(session):
          """
          This example uses the setFootStepsWithSpeed method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # A small step forwards and anti-clockwise with the left foot
          legName = ["LLeg"]
          X       = 0.04
          Y       = 0.1
          Theta   = 0.3
          footSteps = [[X, Y, Theta]]
          fractionMaxSpeed = [1.0]
          clearExisting = False
          motion_service.setFootStepsWithSpeed(legName, footSteps, fractionMaxSpeed, clearExisting)

          time.sleep(0.5)

          # A small step forwards and anti-clockwise with the left foot
          legName = ["LLeg", "RLeg"]
          X       = 0.04
          Y       = 0.1
          Theta   = 0.3
          footSteps = [[X, Y, Theta], [X, -Y, Theta]]
          fractionMaxSpeed = [1.0, 1.0]
          clearExisting = False
          motion_service.setFootStepsWithSpeed(legName, footSteps, fractionMaxSpeed, clearExisting)

          motion_service.waitUntilMoveIsFinished()

          # Go to rest position
          motion_service.rest()

      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::``getFootSteps`()

  Get the actual foot steps vector. This is a non-blocking call.

  Returns: | An ALValue containing three vector with:
      [
        [The actual position of the left and right foot steps in world frame]
        [The unChangeable foot steps]
        [The changeable foot steps]
      ]
  In more details:
      [
        [
          [(float) LFootWorld_X, (float) LFootWorld_Y, (float) LFootWorld_Theta],
          [(float) RFootWorld_X, (float) RFootWorld_Y, (float) RFootWorld_Theta]
        ]
        [
          [(std::string) LegName, (float) Time, [(float) Move_X, (float) Move_Y, (float) Move_Y],
          [...],
          [(std::string) LegName, (float) Time, [(float) Move_X, (float) Move_Y, (float) Move_Y]
        ]
        [
          [(std::string) LegName, (float) Time, [(float) Move_X, (float) Move_Y, (float) Move_Y],
          [...],
          [(std::string) LegName, (float) Time, [(float) Move_X, (float) Move_Y, (float) Move_Y]
        ]
      ]

  Each move of foot step is relative to the previous location of the opposite foot step. For example, a foot step move of LFoot will be relative to the last position of the RFoot.

  If you use setFootSteps or setFootStepsWithSpeed with clearExisting parameter equal true, walk engine execute unchangeable foot step and remove the other.

  `almotion_getFootSteps.py`

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

      """Example: Use getFootSteps Method"""

      import qi
      import argparse
      import sys
      import time

      def main(session):
          """
          This example uses the getFootSteps method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send NAO to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          #####################################
          # A small example using getFootSteps
          #####################################

          # First call of move API
          # Use _async=True argument to not be blocking here.
          motion_service.moveTo(0.3, 0.0, 0.5, _async=True)

          # wait that the move process start running
          time.sleep(1.0)

          # get the foot steps vector
          footSteps = motion_service.getFootSteps()

          # print the result
          leftFootWorldPosition = footSteps[0][0]
          print "leftFootWorldPosition:"
          print leftFootWorldPosition
          print ""

          rightFootWorldPosition = footSteps[0][1]
          print "rightFootWorldPosition:"
          print rightFootWorldPosition
          print ""

          footStepsUnchangeable = footSteps[1]
          print "Unchangeable:"
          print footStepsUnchangeable
          print ""

          footStepsChangeable   = footSteps[2]
          print "Changeable:"
          print footStepsChangeable
          print ""

          motion_service.waitUntilMoveIsFinished()

          # Go to rest position
          motion_service.rest()

      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)

void `ALMotionProxy::``walkInit`()

  Deprecated since version 1.14: use `ALMotionProxy::moveInit` instead.

void `ALMotionProxy::``moveInit`()

  Initializes the move process. Checks the robot pose and takes a right posture. This is blocking called.

  `almotion_moveinit.cpp`

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

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

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

        AL::ALMotionProxy motion(robotIp);
        AL::ALRobotPostureProxy robotPosture(robotIp);
        robotPosture.goToPosture("Stand", 0.5f);

        // Example showing how Initialize move process.
        motion.moveInit();

        return 0;
      }

  `almotion_moveInit.py`

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

      """Example: Use moveInit Method"""

      import qi
      import argparse
      import sys

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

          motion_service = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # Example showing how Initialize move process.
          motion_service.moveInit()

          # Go to rest position
          motion_service.rest()

      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)

void `ALMotionProxy::``waitUntilWalkIsFinished`()

  Waits until the WalkTask is finished: this method can be used to block your script/code execution until the walk task is totally finished.

  Deprecated since version 1.14: use `ALMotionProxy::waitUntilMoveIsFinished` instead.

void `ALMotionProxy::``waitUntilMoveIsFinished`()

  Waits until the MoveTask is finished: this method can be used to block your script/code execution until the move task is totally finished.

  `almotion_waituntilmoveisfinished.cpp`

      #include <iostream>
      #include <alproxies/almotionproxy.h>
      #include <alproxies/alrobotpostureproxy.h>
      #include <qi/os.hpp>

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

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

        AL::ALMotionProxy motion(robotIp);
        AL::ALRobotPostureProxy robotPosture(robotIp);

        robotPosture.goToPosture("StandInit", 0.5f);

        // Example showing how to use waitUntilMoveIsFinished.
        // Start a walk
        float x = 0.10f;
        float y = 0.0f;
        float theta = 0.0f;
        motion.post.moveTo(x, y, theta);

        // Wait for it to finish
        motion.waitUntilMoveIsFinished();
        // Then do something else

        return 0;
      }

  `almotion_waitUntilMoveIsFinished.py`

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

      """Example: Use waitUntilMoveIsFinished Method"""

      import qi
      import argparse
      import sys

      def main(session):
          """
          This example uses the waitUntilMoveIsFinished method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # Example showing how to use waitUntilMoveIsFinished.

          # Start a move
          x = 0.2
          y = 0.0
          theta = 0.0
          motion_service.moveTo(x, y, theta, _async=True)

          # Wait for it to finish
          motion_service.waitUntilMoveIsFinished()

          # Then do something else
          print "Move is finished"

          # Go to rest position
          motion_service.rest()

      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)

bool `ALMotionProxy::``walkIsActive`()

  Returns: | True if Walk is Active.

  Deprecated since version 1.14: use `ALMotionProxy::moveIsActive` instead.

bool `ALMotionProxy::``moveIsActive`()

  Returns: | True if move is Active.

  `almotion_moveisactive.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_moveisactive robotIp "
                    << "(optional default \"127.0.0.1\")."<< std::endl;
        }
        else {
          robotIp = argv[1];
        }

        AL::ALMotionProxy motion(robotIp);

        // Example showing how to use walk is active.
        bool moveIsActive = motion.moveIsActive();

        std::cout << "Move is active: " << moveIsActive << std::endl;

        return 0;
      }

  `almotion_moveIsActive.py`

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

      """Example: Use moveIsActive Method"""

      import qi
      import argparse
      import sys
      import time

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

          motion_service = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # Example showing how to use walk is active.
          # start a 0.2 meter walk
          motion_service.moveTo(0.2, 0.0, 0.0, _async=True)

          while motion_service.moveIsActive():
              # do something
              print "Move is active"

          # sleep a little
          time.sleep(1)

          # when finished do something else

          # Go to rest position
          motion_service.rest()

      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)

bool `ALMotionProxy::``stopWalk`()

  Stops Walk task at next double support: this method will end the walk task less brutally than killWalk but more quickly than move(0.0, 0.0, 0.0).

  Deprecated since version 1.14: use `ALMotionProxy::stopMove` instead.

bool `ALMotionProxy::``stopMove`()

  Stops Move task safely as soon as possible: this method will end the move task less brutally than killMove but more quickly than move(0.0, 0.0, 0.0). This is a blocking call.

  Returns: | True if the stopMove terminated successfully, False if it was interrupted.

AL::ALValue `ALMotionProxy::``getFootGaitConfig`(const std::string& config)

  Gets the foot Gait config (“MaxStepX”, “MaxStepY”, “MaxStepTheta”, “MaxStepFrequency”, “StepHeight”, “TorsoWx”, “TorsoWy”).

  Deprecated since version 1.14: use `ALMotionProxy::getMoveConfig` instead.

  Parameters: | config – a string should be “Max”, “Min”, “Default”
  Returns: | An ALValue with the following form
      [ ["MaxStepX", value],
        ["MaxStepY", value],
        ["MaxStepTheta", value],
        ["MaxStepFrequency", value],
        ["StepHeight", value],
        ["TorsoWx", value],
        ["TorsoWy", value]
      ]

AL::ALValue `ALMotionProxy::``getMoveConfig`(const std::string& config)

  Gets the move config (“MaxStepX”, “MaxStepY”, “MaxStepTheta”, “MaxStepFrequency”, “StepHeight”, “TorsoWx”, “TorsoWy”).

  Parameters: | config – a string should be “Max”, “Min”, “Default”
  Returns: | An ALvalue with the move config. with the following form
      [ ["MaxStepX", value],
        ["MaxStepY", value],
        ["MaxStepTheta", value],
        ["MaxStepFrequency", value],
        ["StepHeight", value],
        ["TorsoWx", value],
        ["TorsoWy", value]
      ]

  Example in python:

      # Example showing how to get and play with foot gait config
      # a getFootConfig could be directly use in a walk method
      # WARNING: be aware that Max and Min are extreme values and could create
      #           some strange walk behavior

      import time

      proxy.moveInit()
      proxy.moveToward(1.0, 0.0, 0.0, proxy.getMoveConfig("Min"))
      time.sleep(3.0)
      proxy.stopMove()

std::vector<float> `ALMotionProxy::``getRobotPosition`(const bool& useSensors)

  Gets the World Absolute Robot Position.

  Parameters: | useSensors – If true, use the MRE sensor values
  Returns: | A vector containing the World Absolute Robot Position. (Absolute Position X in meter, Absolute Position Y in meter, Absolute Angle Theta (Wz) in radian). Wz is an angle between ]-pi, pi].

  `almotion_getrobotposition.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_getrobotposition robotIp "
                    << "(optional default \"127.0.0.1\")."<< std::endl;
        }
        else {
          robotIp = argv[1];
        }

        AL::ALMotionProxy motion(robotIp);

        // Example showing how to get a simplified robot position in world.
        bool useSensorValues = false;
        std::vector<float> result = motion.getRobotPosition(useSensorValues);

        std::cout << "Robot position is: " << result << std::endl;

        return 0;
      }

  `almotion_getRobotPosition.py`

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

      """Example: Use getRobotPosition Method"""

      import qi
      import argparse
      import sys
      import almath

      def main(session):
          """
          This example uses the getRobotPosition method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # Example showing how to get a simplified robot position in world.
          useSensorValues = False
          result = motion_service.getRobotPosition(useSensorValues)
          print "Robot Position", result

          # Example showing how to use this information to know the robot's diplacement.
          useSensorValues = False
          initRobotPosition = almath.Pose2D(motion_service.getRobotPosition(useSensorValues))

          # Make the robot move
          motion_service.moveTo(0.1, 0.0, 0.2)

          endRobotPosition = almath.Pose2D(motion_service.getRobotPosition(useSensorValues))

          # Compute robot's' displacement
          robotMove = almath.pose2DInverse(initRobotPosition)*endRobotPosition
          print "Robot Move:", robotMove

          # Go to rest position
          motion_service.rest()

      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::``getNextRobotPosition`()

  Gets the World Absolute next Robot Position.

  When no walk process active, getNextRobotPosition() = getRobotPosition().

  Else getNextRobotPosition return the position of the robot after the unchangeable foot steps.

  Returns: | A vector containing the World Absolute next Robot position.(Absolute Position X in meter, Absolute Position Y in meter, Absolute Angle Theta (Wz) in radian). Wz is an angle between ]-pi, pi].

  `almotion_getnextrobotposition.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_getnextrobotposition robotIp "
                    << "(optional default \"127.0.0.1\")."<< std::endl;
        }
        else {
          robotIp = argv[1];
        }

        AL::ALMotionProxy motion(robotIp);

        // Example showing how to get a simplified next robot position in world.
        std::vector<float> result = motion.getNextRobotPosition();

        std::cout << "Next robot position is: " << result << std::endl;

        return 0;
      }

  `almotion_getNextRobotPosition.py`

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

      """Example: Use getNextRobotPosition Method"""

      import qi
      import argparse
      import sys
      import time
      import almath

      def main(session):
          """
          This example uses the getNextRobotPosition method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send NAO to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          # Example showing how to get a simplified robot position in world.
          result = motion_service.getNextRobotPosition()
          print "Next Robot Position", result

          # Example showing how to use this information to know the robot's diplacement
          # during the move process.

          # Make the robot move
          motion_service.moveTo(0.6, 0.0, 0.5, _async=True) # No blocking due to post called
          time.sleep(1.0)
          initRobotPosition = almath.Pose2D(motion_service.getNextRobotPosition())

          # Make the robot move
          motion_service.moveTo(0.1, 0.0, 0.2)

          endRobotPosition = almath.Pose2D(motion_service.getNextRobotPosition())

          # Compute robot's' displacement
          robotMove = almath.pose2DInverse(initRobotPosition)*endRobotPosition
          print "Robot Move :", robotMove

          # Go to rest position
          motion_service.rest()

      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::``getRobotVelocity`()

  Gets the Absolute Robot Velocity, expressed in FRAME_ROBOT.

  Returns: | A vector containing the Absolute Robot Velocity. (Absolute Velocity Translation X [m.s-1], Absolute Velocity Translation Y[m.s-1], Absolute Velocity Rotation WZ [rd.s-1])

  `almotion_getrobotvelocity.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_getrobotvelocity robotIp "
                    << "(optional default \"127.0.0.1\")."<< std::endl;
        }
        else {
          robotIp = argv[1];
        }

        AL::ALMotionProxy motion(robotIp);

        // Example showing how to get a simplified absolute robot velocity in FRAME_ROBOT.
        std::vector<float> result = motion.getRobotVelocity();

        std::cout << "Robot velocity is: " << result << std::endl;

        return 0;
      }

  `almotion_getRobotVelocity.py`

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

      """Example: Use getRobotVelocity Method"""

      import qi
      import argparse
      import sys

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

          motion_service  = session.service("ALMotion")

          # Example showing how to get a simplified absolute robot velocity in FRAME_ROBOT.
          result = motion_service.getRobotVelocity()
          print "Robot Velocity: ", result

      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::``getWalkArmsEnabled`()

  Deprecated since version 1.22: use `ALMotionProxy::getMoveArmsEnabled` instead.

  Gets if Arms Motions are enabled during the Walk Process.

  Returns: | True Arm Motions are controlled by the Walk Task.

void `ALMotionProxy::``setWalkArmsEnabled`(const bool& leftArmEnable, const bool& rightArmEnable)

  Deprecated since version 1.22: use `ALMotionProxy::setMoveArmsEnabled` instead.

  Sets if Arms Motions are enabled during the Walk Process.

  Parameters: | leftArmEnable – if true Left Arm motions are controlled by the Walk Task rightArmEnable – if true Right Arm motions are controlled by the Walk Task

bool `ALMotionProxy::``getMoveArmsEnabled`(const std::string& chainName)

  Gets if Arms Motions are enabled during the Move Process.

  Parameters: | chainName – arm chain, it should be “LArm”, “RArm” or “Arms”.
  Returns: | For “LArm” and “RArm”, returns true if the corresponding arm is enabled. For “Arms”, returns true if both arms are enabled. Returns false otherwise.

  `almotion_getMoveArmsEnabled.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_getMoveArmsEnable robotIp "
                    << "(optional default \"127.0.0.1\")."<< std::endl;
        }
        else {
          robotIp = argv[1];
        }

        AL::ALMotionProxy motion(robotIp);

        // Example showing how to get the enabled flags for the arms
        std::cout << "LeftArmEnabled: " << motion.getMoveArmsEnabled("LArm") << std::endl;
        std::cout << "RightArmEnabled: " << motion.getMoveArmsEnabled("RArm") << std::endl;
        std::cout << "BothArmsEnabled: " << motion.getMoveArmsEnabled("Arms") << std::endl;
        return 0;
      }

  `almotion_getMoveArmsEnable.py`

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

      """Example: Use getMoveArmsEnabled Method"""

      import qi
      import argparse
      import sys

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

          motion_service  = session.service("ALMotion")

          # Example showing how to get the enabled flags for the arms
          print 'LeftArmEnabled: ', motion_service.getMoveArmsEnabled("LArm")
          print 'RightArmEnabled: ', motion_service.getMoveArmsEnabled("RArm")
          print 'BothArmsEnabled: ', motion_service.getMoveArmsEnabled("Arms")

      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)

void `ALMotionProxy::``setMoveArmsEnabled`(const bool& leftArmEnable, const bool& rightArmEnable)

  Sets if Arms Motions are enabled during the Move Process.

  Parameters: | leftArmEnable – if true Left Arm motions are controlled by the Move Task rightArmEnable – if true Right Arm motions are controlled by the Move Task

  `almotion_setMoveArmsEnabled.py`

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

      """Example: Use setMoveArmsEnabled Method"""

      import qi
      import argparse
      import sys
      import time

      def main(session):
          """
          This example uses the setMoveArmsEnabled method.
          """
          # Get the services ALMotion & ALRobotPosture.

          motion_service  = session.service("ALMotion")
          posture_service = session.service("ALRobotPosture")

          # Wake up robot
          motion_service.wakeUp()

          # Send robot to Pose Init
          posture_service.goToPosture("StandInit", 0.5)

          x          = 0.6
          y          = 0.0
          theta      = 0.0
          motion_service.moveToward(x, y, theta)

          time.sleep(2.0)

          # Example showing how to disable left arm motions during a move
          leftArmEnable  = False
          rightArmEnable = True
          motion_service.setMoveArmsEnabled(leftArmEnable, rightArmEnable)
          print "Disabled left arm"

          # disable also right arm motion after 1 seconds
          time.sleep(1.0)
          rightArmEnable  = False
          motion_service.setMoveArmsEnabled(leftArmEnable, rightArmEnable)
          print "Disabled right arm"

          time.sleep(1.0)

          motion_service.stopMove()

          leftArmEnable  = True
          rightArmEnable = True
          motion_service.setMoveArmsEnabled(leftArmEnable, rightArmEnable)

          # Go to rest position
          motion_service.rest()

      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)

Glossary Site map Index Support Contact Legal Notices