You can browse the file system to examine one of these posture files by starting at the "Root Control" menu, going to "File Access", selecting the "Files" submenu, and double clicking on a file or directory name. Posture files are in the directory data/motion/robotname, e.g., for the AIBO ERS-7 they are in data/motion/ers7. Click on the file LIEDOWN.POS and it will be printed to the console. You can also find these files on your hard drive, in ~/project/ms/data/motion/robotname.

Posture files always begin with the comment line "#POS" and end with "#END". Here is what LIEDOWN.POS looks like on the AIBO. The first column is the joint name, the second is the joint angle, and the third is the weight, which is normally 1.0. (Weights are used by the motion manager when blending motions together.)

The Chiara has six legs, so its body postures will look somewhat different than the AIBO's. Some robots, such as the Create/ASUS, have no joints at all, so their postures consist of just motor speeds and LED states.

When the AIBO is stopped, you can bend the legs, head, and tail to any desired position, and the Posture Editor will update its list of joint positions to reflect their current values. On the Chiara you can do this by executing the Relax script. Once the robot is un- stopped, the Posture Editor will let you numerically edit the joint positions by selecting one or more items in the menu and entering a number in the input text field.

Once you have the posture the way you like it, you can use the "Save Posture" command to write the joint angles to a file on the robot.uses the extension ".POS". If you do not specify a path, the files will be stored in /ms/data/motion. You should copy the file to the corresponding location in the ~/project/ms/data/motion directory on your hard drive, so that it will be in sync with your robot.

Tekkotsu provides several built-in motion sequences which you can experiment with.

Motion sequence files always begin with the comment line "#MSq" and end with "#END". Here is what PAN_HEAD.MOT looks like:

The "degrees" command indicates that joint values are in degrees. There is also a "radians" command.

The "advanceTime n" command (also called delay in earlier versions of Tekkotsu) advances the time index by n milliseconds. The convention is that you advance the time index first, then specify the new joint positions to be achieved at that time. The system will adjust the joint velocities so that the joints arrive at their target positions at the specified times. So the motion sequence above takes 50 msec to move the head from its initial position (whatever that might be) to a neutral position (tilt 15 degrees and roll 0.). After another 850 msec the neck should be panned 45 degrees to the right. Finally, after another 900 msec, the neck should be panned 45 degrees to the left.

Other motion sequence commands include "load posturefile", which loads a set of joint angles from a file, "overlay filename", which overlays a posture file onto the sequence presently being constructed, and "setTime t", which sets the time index to an absolute time value, rather than adjusting it by a relative value as the advanceTime (or delay) command does.

The STANDLIE.MOT motion sequence tells the robot to stand, then sit up, and then lie down. The sequence is poorly designed: if you try it with an AIBO starting out in the lying down position, you will see that going from stand to sit causes it to nearly tip over.

A tricky aspect of motion sequences results from the fact that each joint maintains its own list of keyframes, independent of the other joints. When a new position is specified for a joint, the MotionSequenceEngine calculates a speed that will move the joint smoothly from its last position, at the time it was specified, to the new position. It doesn't matter what the other joints have been doing. This allows for head and body motions to be controlled independently, but it can lead to nonintuitive results when constructing motion sequences if you don't pay attention to when each joint was last updated. For example, supposed we want to move an AIBO's head and tail to neutral positions, then shake the head left and right, return the head to neutral, and then wag the tail. The example motion sequence below will not do what we expect unless the line in red is included:

The problem with HEADWAG without the red line is that the tail's position is specified as neutral at time 50, and the joint us not referenced again until the first wag position is given. So the tail wag motion will actually begin at time 50, not time 2550, and it will be spread out over 3000 msec so that the tail is at 90 degrees at time 3050. To achieve the effect we want, with the tail starting to move only after the head shake is completed at 2550, we need to re-specify the tail's position just before the tail is to begin moving. That's what the line in red is for.

Explore more:

1. Design a better motion sequence to take the AIBO from lying down to standing to sitting, without risk of toppling over. There are a number of approaches you could take. For example, you could create an intermediate posture between stand and sit that moves the AIBO to a safer position.

2. Stop the robot by clicking on the "stop" button in the ControllerGUI. Then try to run a motion sequence. What sound does the robot make? What happens when you then un-stop the robot?

3. Suppose you want the robot to move to a pose and hold it for 5 seconds before moving on to another pose. The way to do this is to move to the first pose, then advance the time by 5 seconds and move to the same pose again. Then advance the time normally and move to the next pose. Try it and see how it works.

4. Use the Posture Editor to explore the meaning of the various LED settings. Figure out how to turn the various LEDs on and off. Then, design a motion sequence to display s brief series of patterns and colors.

5. Suppose you want an AIBO to stand up and pan its head to the left at the same time, then lie down again while panning its head to the right. Construct a posture file for panning the head to the left, and another for panning to the right. Then construct a motion sequence file that uses the load, setTime, and overlay commands to create the compound sequence described above.

Programming Motion Sequences

#include "Behaviors/StateMachine.h"
#include "Shared/mathutils.h"     // for deg2rad function

using namespace mathutils;

$nodeclass MSeqTest : DynamicMotionSequenceNode : doStart {

    float const leftGlanceAngle = deg2rad(60.0);
    float const rightGlanceAngle = deg2rad(-70.0);
    float const downGlanceAngle = deg2rad(-55.0);

    MMAccessor<DynamicMotionSequence> mseq_acc = getMC();

    // 1 sec to move head to look straight ahead
    PostureEngine lookstraight;
    lookstraight.setOutputCmd(HeadOffset+TiltOffset, 0.0);
    lookstraight.setOutputCmd(HeadOffset+PanOffset, 0.0);
    mseq_acc->advanceTime(1000);
    mseq_acc->setPose(lookstraight);

    mseq_acc->advanceTime(5000);    // 5 secs to sit up
    mseq_acc->LoadFile("situp.pos");

    mseq_acc->advanceTime(1000);    // 1 sec to glance left
    mseq_acc->setOutputCmd(HeadOffset+PanOffset, leftGlanceAngle);

    mseq_acc->advanceTime(2000);    // hold glance for 2 secs
    mseq_acc->setOutputCmd(HeadOffset+PanOffset, leftGlanceAngle);


    mseq_acc->advanceTime(1000);    // 1 sec to glance right
    mseq_acc->setOutputCmd(HeadOffset+PanOffset, rightGlanceAngle);

    mseq_acc->advanceTime(2000);    // hold glance right for 2 secs
    mseq_acc->setOutputCmd(HeadOffset+PanOffset, rightGlanceAngle);
    mseq_acc->setOutputCmd(HeadOffset+TiltOffset, 0.0);// re-specify tilt in preparation for moving

    mseq_acc->advanceTime(1000);    // 1 sec to glance down
    PostureEngine currentpose("situp.pos");  // update body joint time indices
    currentpose.setOutputCmd(HeadOffset+TiltOffset, downGlanceAngle);  // and tilt the head down
    mseq_acc->setPose(currentpose);

    mseq_acc->advanceTime(5000);    // 5 secs to lie down
    mseq_acc->LoadFile("liedown.pos");
    mseq_acc->setOutputCmd(HeadOffset+TiltOffset, downGlanceAngle);
}

REGISTER_BEHAVIOR(MSeqTest);

We used an MMAccessor above for convenience; it holds the pointer returned by getMC() so we only have to call getMC() once..

Note also that the setOutputCmd() function wants an OutputCmd object as a second argument, but the code above supplies a floating point number. OutputCmd's constructor provides an implicit type conversion that permits this shortcut, so writing setOutputCmd(j,x) is equivalent to writing setOutputCmd(j,OutputCmd(x)).

Normally we use a DynamicMotionSequence, which can be of any size. But this is not available on the AIBO, which uses MotionSequenceMC instead. MotionSequenceMC objects must be of fixed size because of the way they are allocated in shared memory on the AIBO. Larger objects can store more keyframes. Tekkotsu provides a built in range of pre-sized motion sequence commands, shown below; the list is taken from MotionSequenceMC.h. The constant NumOutputs, defined in ERS7Info.h, is 47, so a TinyMotionSequenceMC, which can hold 2 completely-specified postures, has room for 94 keyframes. It can hold considerably more postures if only a few joints are being controlled at each step. For example, Tekkotsu-supplied posture files like STAND.POS specify only leg joint positions; they do not control the head or the LEDs.

If you save a posture from the Posture Editor, all 47 output values will be saved. However, if you don't want to your posture to control certain output values, you can click on the Weights item in the Posture Editor and set their weights to zero, in which case they will not be stored in the .POS file.. Alternatively, you could manually edit the .POS file to remove outputs you don't care about.