Stiffness control API

NAOqi Motion - Overview | API


Methods

void ALMotionProxy::wakeUp()

The robot wakes up: sets Motor on and, if needed, goes to initial position. For example, H25 or H21 sets the Stiffness on and keeps is current position.

almotion_wakeUp.py


# -*- encoding: UTF-8 -*-

'''Wake up: sets Motor on and, if needed, goes to initial position'''

import time
import argparse
from naoqi import ALProxy

def main(robotIP, PORT=9559):

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

    motionProxy.wakeUp()

    # print motion state
    print motionProxy.getSummary()
    time.sleep(4.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")

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

void ALMotionProxy::rest()

The robot rests: goes to a relaxed and safe position and sets Motor off. For example, H25 or H21 goes to the Crouch posture and sets the Stiffness off.

almotion_rest.py


# -*- encoding: UTF-8 -*-

'''Rest: goes to a relaxed and safe position and sets Motor off'''

import argparse
from naoqi import ALProxy

def main(robotIP, PORT=9559):
    motionProxy  = ALProxy("ALMotion", robotIP, PORT)
    postureProxy = ALProxy("ALRobotPosture", robotIP, PORT)

    # Wake up robot
    motionProxy.wakeUp()

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

    # Go to rest position
    motionProxy.rest()

    # print motion state
    print motionProxy.getSummary()


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

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

bool ALMotionProxy::robotIsWakeUp()
Returns: True if the robot is awake.
void ALMotionProxy::stiffnessInterpolation(const AL::ALValue& names, const AL::ALValue& stiffnessLists, const AL::ALValue& timeLists)

Interpolates one or multiple joints to a targeted stiffness or along timed trajectories of stiffness. This is a blocking call.

Parameters:
  • names – Name or names of joints, chains, “Body”, “JointActuators”, “Joints” or “Actuators”.
  • stiffnessLists – An stiffness, list of stiffnesses or list of list of stiffnesses
  • timeLists – A time, list of times or list of list of times.

almotion_stiffnessInterpolation.py


# -*- encoding: UTF-8 -*-

import time
import argparse
from naoqi import ALProxy

def main(robotIP, PORT=9559):
    motionProxy = ALProxy("ALMotion", robotIP, PORT)

    # Example showing how to interpolate to maximum stiffness in 1 second
    names  = 'Body'
    stiffnessLists  = 0.0
    timeLists  = 1.0
    motionProxy.stiffnessInterpolation(names, stiffnessLists, timeLists)

    time.sleep(1.0)

    # Example showing a stiffness trajectory for a single joint
    names  = ['HeadYaw']
    stiffnessLists  = [0.25, 0.5, 1.0, 0.0]
    timeLists  = [1.0, 2.0, 3.0, 4.0]
    motionProxy.stiffnessInterpolation(names, stiffnessLists, timeLists)


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

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

void ALMotionProxy::setStiffnesses(const AL::ALValue& names, const AL::ALValue& stiffnesses)

Sets the stiffness of one or more joints. This is a non-blocking call.

Parameters:
  • names – Names of joints, chains, “Body”, “JointActuators”, “Joints” or “Actuators”.
  • stiffnesses – One or more stiffnesses between zero and one.

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

  AL::ALMotionProxy motion(robotIp);

  // Example showing how to set the stiffness to 1.0.
  // Beware, doing this could be dangerous, it is safer to use the
  // stiffnessInterpolation method which takes a duration parameter.
  std::string names  = "Body";
  // If only one parameter is received, this is applied to all joints
  float stiffnesses  = 1.0f;
  motion.setStiffnesses(names, stiffnesses);

  return 0;
}

almotion_setStiffnesses.py


# -*- encoding: UTF-8 -*-

import argparse
from naoqi import ALProxy

def main(robotIP, PORT=9559):
    motionProxy = ALProxy("ALMotion", robotIP, PORT)

    # Example showing how to set the stiffness to 1.0.
    # Beware, doing this could be dangerous, it is safer to use the
    #   stiffnessInterpolation method which takes a duration parameter.
    names  = 'Body'
    # If only one parameter is received, this is applied to all joints
    stiffnesses  = 1.0
    motionProxy.setStiffnesses(names, stiffnesses)

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

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

std::vector<float> ALMotionProxy::getStiffnesses(const AL::ALValue& jointName)

Gets stiffness of a joint or group of joints

Parameters:
  • jointName – Name of the joints, chains, “Body”, “JointActuators”, “Joints” or “Actuators”.
Returns:

One or more stiffnesses. 1.0 indicates maximum stiffness. 0.0 indicated minimum stiffness

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

  AL::ALMotionProxy motion(robotIp);

  // Example showing how to get the Body stiffnesses
  std::string jointName = "Body";
  std::vector<float> stiffnesses = motion.getStiffnesses(jointName);

  std::cout << jointName << "stiffnesses: " << stiffnesses << std::endl;

  return 0;
}

almotion_getStiffnesses.py


# -*- encoding: UTF-8 -*-

import argparse
from naoqi import ALProxy

def main(robotIP, PORT=9559):
    motionProxy = ALProxy("ALMotion", robotIP, PORT)

    # Example showing how to get the Body stiffnesses
    jointName   = "Body"
    stiffnesses = motionProxy.getStiffnesses(jointName)
    print "Body Stiffnesses:"
    print stiffnesses


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

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

Events

Event: "robotIsWakeUp"
callback(std::string eventName, bool val, std::string subscriberIdentifier)

Raised when the awake status of the robot changes.

Parameters:
  • eventName (std::string) – “robotIsWakeUp”
  • val – True if the robot is awake. False if the robot is not awake.
  • subscriberIdentifier (std::string) –
Event: "ALMotion/Stiffness/wakeUpStarted"
callback(std::string eventName, bool val, std::string subscriberIdentifier)

Raised at ALMotionProxy::wakeUp() start.

Parameters:
  • eventName (std::string) – “ALMotion/Stiffness/wakeUpStarted”
  • val – always True.
  • subscriberIdentifier (std::string) –
Event: "ALMotion/Stiffness/wakeUpFinished"
callback(std::string eventName, bool val, std::string subscriberIdentifier)

Raised at ALMotionProxy::wakeUp() finish.

Parameters:
  • eventName (std::string) – “ALMotion/Stiffness/wakeUpFinished”
  • val – always True.
  • subscriberIdentifier (std::string) –
Event: "ALMotion/Stiffness/restStarted"
callback(std::string eventName, bool val, std::string subscriberIdentifier)

Raised at ALMotionProxy::rest() start.

Parameters:
  • eventName (std::string) – “ALMotion/Stiffness/restStarted”
  • val – always True.
  • subscriberIdentifier (std::string) –
Event: "ALMotion/Stiffness/restFinished"
callback(std::string eventName, bool val, std::string subscriberIdentifier)

Raised at ALMotionProxy::rest() finish.

Parameters:
  • eventName (std::string) – “ALMotion/Stiffness/restFinished”
  • val – always True.
  • subscriberIdentifier (std::string) –
Event: "ALMotion/Protection/DisabledDevicesChanged"
callback(std::string eventName, AL::ALValue val, std::string subscriberIdentifier)

Raised when devices availability changed. When a device is not available the stiffness and movement on this device are prohibited.

The ALValue format is: [[std::string deviceName, bool disabled],...] deviceName could be a chainName or “Body”. In “Body” case ( [[“Body”, true]] ) ALMotionProxy::wakeUp() are prohibited.

Parameters:
  • eventName (std::string) – “ALMotion/Protection/DisabledDevicesChanged”
  • val – An ALValue with the actual disabled devices status. * Example: [[“LArm”, true]], [“Head”, false]]
  • subscriberIdentifier (std::string) –