Recent Changes - Search:
Email iofreak@yahoo.com with comments and/or suggestions.

Aibo General

Aibo Development

Wiki Help

Aibo Links

R-Code » ERS 110/111 Official Reference
===========================================================================

	R-CODE110/111 for ERS-110/111

	Copyright (C) 2002 Sony Corporation

	All Rights Reserved.

===========================================================================


Reference Manual


[ List of R-CODE Commands ]
[ R-CODE Commands ]
[ List of R-CODE System Variables ]
[ Quick Reference of R-CODE Operators ]
[ List of Semantics of AIBO Performer Kit ]
[ ESC File ]
[ Motion Definition File ]
[ Musical Scale Recognition File ]



[ List of R-CODE Commands ]

Controls

   HALT          finishes the program and shuts down AIBO.
   DEF           registers poses/motions.
   SET           specifies joint angles individually.
   SET_MOVE      updates part of a motion.
   SET_POSE      changes the angle data of the joints of poses.
   REC           records a motion.
   LOAD_POSE     loads poses from the "Memory Stick".
   SAVE_POSE     saves poses to the "Memory Stick".
   LIMITTER      controls motion.

Motions

   POSE          takes a pose.
   PLAY          performs a motion.
   MOVE          performs a motion.
   STOP          stops a motion.
   QUIT          stops a motion abruptly.
   WAIT          waits.
   PLAY:APK      performs a registered motion.
   POSE:APK      takes a registered pose.

Control Structures

   :             defines a line to be a label.
   GO            jumps the process to the specified label.
   IF            conditional test statement.
   SWITCH        branches the process.
   CSET          sets a context value.
   CASE          branches the process.
   FOR           generates a FOR loop.
   NEXT          terminates a FOR Loop.
   WHILE         generates a WHILE loop.
   WEND          terminates a WHILE Loop.
   REPEAT        generates a REPEAT loop.
   UNTIL         terminates a REPEAT Loop.
   DO            generates a DO loop.
   LOOP          terminates a DO loop.
   BREAK         breaks a loop.
   CALL          calls a subroutine.
   ARG           fetches an argument of a subroutine.
   RETURN        returns from a subroutine.
   RET           returns from a subroutine (for context version).
   ONCALL        registers an interrupt routine.
   RESUME        returns from an interrupt routine.

Variables

   GLOBAL        declares a variable as a global variable.
   LOCAL         declares a variable as a local variable.
   LET           assigns a value (simple assignment).
   SET           assigns a value (assignment with a special function)

Operation

   ADD           Addition
   SUB           Subtraction
   MUL           Multiplication
   DIV           Division
   MOD           Remainder
   AND           Logical AND
   IOR           Logical OR
   XOR           Exclusive OR
   NOT           Negation
   LAND          Logical AND (Boolean operation)
   LIOR          Logical OR (Boolean operation)
   LNOT          Negation (Boolean operation)
   EQ            Equal to
   NE            Not equal to
   LT            Less than
   LE            Less than or equal to
   GT            Greater than
   GE            Greater than or equal to
   RND           Random number

Stack Operation

   PUSH          pushes data onto a stack.
   POP           pops data from a stack.
   DUP           copies the top entry on a stack.
   JT            jumps if the top entry on a stack is true.
   JF            jumps if the top entry on a stack is false.






[ R-CODE Commands ]
---------------------------------------------------------------------------

Name
         HALT - finishes the program and shuts down AIBO.

Format
         HALT

Argument
         None

Description
         This command will stop the running program and shutdown AIBO.
         It will take a few seconds for AIBO to shutdown.

Example
         EDIT
         SET:Power:1
         FOR:i:1:10
           PLAY:SOUND:xxx:100
           WAIT:SOUND
         NEXT
         HALT
         END

---------------------------------------------------------------------------

Name-
         POSE - moves AIBO to the starting pose of a motion.

Format
     Common format
     POSE:<region>:<motion>:<sound>:<light>:<wait>

     POSE:AIBO:<aibo>[:<sound>:<light>:<wait>] To the starting pose of a motion
     POSE:HEAD:<head>[:<sound>:<light>:<wait>] To the starting pose of a motion
     POSE:LEGS:<legs>[:<sound>:<light>:<wait>] To the starting pose of a motion
     POSE:TAIL:<tail>[:<sound>:<light>:<wait>] To the starting pose of a motion

     POSE:HLT:<head>:<legs>:<tail>:<sound>:<light>:<wait>  HEAD+LEGS+TAIL

         POSE:ESC:<semantics>:<wait>:<semantics>:<semantics>:<semantics>

Arguments
         <region>        Regions [ AIBO | HEAD | LEGS | TAIL ]

         <motion>        Motion name
           <aibo>        Motion name of the whole body
           <head>        Motion name of the head
           <legs>        Motion name of the 4 legs
           <tail>        Motion name of the tail

         <sound>         Sound name
         <light>         Name of the LED light pattern

         <semantics>     Semantics name

         <wait>          Wait flag for the end of a motion [0: Don't wait, 1: Wait]

Description
         This command makes AIBO move to the starting pose of the specified <motion>.
         The motion names, specified with <motion>, varies depending on <region>.
         Refer to the following files for the motion names specified to each region, and for the starting pose of each motion.

             <region>          .cfg file
             AIBO (Motion of the whole body)  /OPEN-R/SONY/CONF/monet_01(00).cfg
             HEAD (Motion of the head)        /OPEN-R/SONY/CONF/head_01(00).cfg
             LEGS (Motion of the 4 legs)      /OPEN-R/SONY/CONF/legs_01(00).cfg
             TAIL (Motion of the tail)        /OPEN-R/SONY/CONF/tail_01(00).cfg

         The 01.cfg files can be modified to change the motion name.
	 The 00.cfg files are not editable.  These are the only motions
	 that are included as system motions.
	 NOTE: The system motion names should not be changed.

         You can specify <sound>/<light>, the sound and the light that should
         be played back while AIBO moves to the starting pose of a motion.
         The synchronization of the motion and sound/light is not controllable, because
         the transition from the current posture to the
         starting one varies depending on the current posture.
         The sound and the light are played back when you execute the POSE command.

         Specify 1 to <wait> and the sound/light is not played back until AIBO
         moves to the starting pose of a motion.

         * When you turn on AIBO, it is in an unknown pose.  To change the pose
           from the unknown, specify the sleep pose so that the front and the rear
           legs do not collide with each other.
Example
         POSE:AIBO:slp_slp:::1

---------------------------------------------------------------------------

Name
         PLAY - makes AIBO perform a motion.

Format
         Common format
         PLAY:<region>:<motion>:<sound>:<light>:<wait>

         PLAY:AIBO:<aibo>[:<sound>:<light>:<wait>]     Motion of the whole body
         PLAY:HEAD:<head>[:<sound>:<light>:<wait>]     Motion of the head
         PLAY:LEGS:<legs>[:<sound>:<light>:<wait>]     Motion of the legs
         PLAY:TAIL:<tail>[:<sound>:<light>:<wait>]     Motion of the tail

         PLAY:HLT:<head>:<legs>:<tail>:<sound>:<light>:<wait>   HEAD+LEGS+TAIL

         PLAY:ESC:<semantics>[:<wait>:<semantics>:<semantics>:<semantics>]

         PLAY:SOUND:<sound>[:<volume>:<if_not_busy>:<wait>] Playback of sound
         PLAY:LIGHT:<light>[:<repeat>:<if_not_busy>:<wait>] Playback of light (LED pattern) 
Argument
         <region>        Regions [ AIBO | HEAD | LEGS | TAIL ]

         <motion>        Motion name
         <aibo>          Motion name of the whole body
         <head>          Motion name of the head
         <legs>          Motion name of the 4 legs
         <tail>          Motion name of the tail

         <sound>         Sound name

           volume = 0 to 100  Default = Sound_volume

           It is possible to specify the volume of sound by entering a value next to "<" in <sound>.
                 Example:
                      PLAY:SOUND:Test1<100 --> PLAY:SOUND:Test1:100.

         <light>         Name of the LED light pattern.

                 repeat = 0 to 16 (0:Default 16:Loop) Default = Light_repeat

                 It is possible to specify "repeat" by entering a value next to "*" in <light>.
                 Example:
                      PLAY:LIGHT:Test*3 --> PLAY:LIGHT:Test1:3.

         <semantics>     Semantics name

         <wait>         Wait flag for the end of a motion [0: Don't wait, 1: Wait]

Description
         This command makes AIBO perform the specified <motion>.
         The motion names, specified with <motion>, vary depending on <region>.
         Refer to the following files for the motion names specified to each <region>, 
         and the starting pose of each <motion>.

             <region>          .cfg file
             AIBO (Motion of the whole body)  /OPEN-R/SONY/CONF/monet_01(00).cfg
             HEAD (Motion of the head)        /OPEN-R/SONY/CONF/head_01(00).cfg
             LEGS (Motion of the 4 legs)      /OPEN-R/SONY/CONF/legs_01(00).cfg
             TAIL (Motion of the tail)        /OPEN-R/SONY/CONF/tail_01(00).cfg

         The 01.cfg files define the list of external motions.
         The 00.cfg files define the list of internal motions.

         To let AIBO make a specific motion, you can check if AIBO is currently
         in the starting pose of that motion.
         If it is not in the starting pose, the pose automatically changes to the
         starting pose.
         AIBO only performs <motion> when it is in the starting pose.

         You can specify <sound>/<light>, the sound and the light to be played
         back in sync with <motion>.
         <sound>/<light> is played back in sync with <motion> when AIBO is in the
         starting pose.

Specify 1 to <wait> and the processes are blocked until AIBO finishes the motion.

Example
         PLAY:AIBO:oStanding:::1

---------------------------------------------------------------------------

Name
         MOVE - makes AIBO perform a built-in motion.

Format
         Common format
         MOVE:<region>:<motion>:<arg1>:<arg2>:<arg3>:<arg4>

         MOVE:AIBO:<aibo>           AIBO performs built-in motions (e.g. getting up from the fall-down state)

         MOVE:LEGS:WALK:<w_style>:<dir>            Walks.
         MOVE:LEGS:STEP:<w_style>:<dir>:<steps>    Walks.  (StepWalk)
         MOVE:LEGS:KICK:<k_style>:<deg>            Performs a kick motion.

         MOVE:HEAD:HOME                            Moves the head to the home position.
         MOVE:HEAD:ABS:<tilt>:<pan>:<roll>:<time>  Moves the head to the absolute position.
         MOVE:HEAD:REL:<tilt>:<pan>:<roll>:<time>  Moves the head to a relative position.
         MOVE:HEAD:C-TRACKING                      Moves the head in the track of a color.
         MOVE:HEAD:C-TRACKING:<time>               Moves the head in the track of a color.
         MOVE:TAIL:HOME                            Moves the tail to the home position.
         MOVE:TAIL:ABS:<tilt>:<pan>:<time>         Moves the tail to the absolute position.
         MOVE:TAIL:SWING:<tilt>:<pan>:<time>       Swings the tail.

Argument
         <region>        Region [ AIBO | HEAD | LEGS | TAIL ]

         <motion>        Motion name
         <arg1> to <arg4>  Argument (depending on commands)

         <aibo>          Built-in motion name of the whole body

                         NToStand    From an unknown pose to the standing pose
                         NToSleep    From an unknown pose to the sleeping pose
                         NToSit      From an unknown pose to the sitting pose
                         NToPStation From an unknown pose to the station preparation pose
                         PSToStation From the station preparation pose to the station pose
                         ReactiveGU  AIBO recovers from the fallen down (FD) state to the standing pose.
                         NToFD       From an unknown pose to the fallen down state: No motion takes place.

         <w_style>       Walking style      [ 0 to 10 | 12(R-Turn) | 13(L-Turn) ]
         <k_style>       Kicking style      [         14(R-Kick) | 15(L-Kick) ]
         <dir>           Advancing direction [ 1 to 6 ] 1: Front 2: Right-front 3: Left-front 4: Right side 5: Left side 6: Move backward
         <deg>           Kicking direction (angle)    [ -90 to 90 ] Unit:[degree]
         <steps>         The number of repeated steps  [ 0 to 9999 ]

         <tilt>          Tilting angle     [ -180 to 180 ] Unit:[degree]
         <pan>           Panning angle     [ -180 to 180 ] Unit:[degree]
         <roll>          Rolling angle     [ -180 to 180 ] Unit:[degree]
         <time>          Moving time       [  0 to 30000 ] Unit:[ms]

Description
	This command makes AIBO perform the built-in motion specified with <motion>.

Example
         MOVE:LEGS:WALK:1:1

---------------------------------------------------------------------------

Name
         STOP - stops a motion.

Format
         Common format
         STOP:<region>

         STOP:AIBO                          stops the whole body.
         STOP:LEGS                          stops the motion of the legs.
         STOP:HEAD                          stops the motion of the head.
         STOP:TAIL                          stops the motion of the tail.

         STOP:SOUND                         stops the playback of sound.
         STOP:LIGHT                         stops the playback of sound.

Argument
         <region>        Regions [ AIBO | HEAD | LEGS | TAIL ]

Description
         This command stops the motion of AIBO.
         Motions kept in the queue are all discarded.

         When AIBO is performing a motion, it stops motions after completing it.

Example
         STOP:AIBO

---------------------------------------------------------------------------

Name
         QUIT - stops a motion abruptly.

Format
         Common format
         QUIT:<region>

         QUIT:AIBO                abruptly stops the motion of the whole body.
         QUIT:LEGS                abruptly stops the 4 legs.
         QUIT:HEAD                abruptly stops the head.
         QUIT:TAIL                abruptly stops the tail.

         QUIT:SOUND    (equals STOP:SOUND)           stops the sound.
         QUIT:LIGHT    (equals STOP:LIGHT)           stops the light.

Argument
         <region>        Regions [ AIBO | HEAD | LEGS | TAIL ]

Description
         This command stops a motion abruptly.
         Motions kept in the queue are all discarded.
         It also abruptly stops the currently performing motion.


         *When you execute the "QUIT" command to those except SOUND/LIGHT,
         the posture of AIBO is reset to oNEUTRAL.

Example
         QUIT:AIBO

---------------------------------------------------------------------------

Name
         WAIT - makes AIBO wait for the completion of a motion (Sync).

Format
         WAIT           waits for the completion of a given motion currently being executed.

         WAIT:AIBO      waits for the completion of the motion of the whole body currently being executed.
         WAIT:HEAD      waits for the completion of the motion of the head currently being executed 
         WAIT:LEGS      waits for the completion of the motion of the legs currently being executed 
         WAIT:TAIL      waits for the completion of the motion of the tail currently being executed 

         WAIT:SOUND     waits for the completion of the playback of sound (Also able to check whether sound is currently being played back or not).
         WAIT:LIGHT     waits for the completion of the playback of light (Also able to check whether light is currently begin played back or not).

         WAIT:<ms>      waits for the specified amount of time.

Argument
         <ms>        Millisecond  [1 to 30000]   Note: The resolution is 32[ms].

Description
         This command is used to suspend AIBO's next motion until a specified condition is met.
         The execution of the program is suspended until the condition is met.

         If you execute <WAIT> when nothing is in the queue, the process is suspended, but restarted in about 32[ms].

Example
         WAIT:AIBO

---------------------------------------------------------------------------

Name
         :<label> - defines a line to be a label.

Format
         :<label>

Argument
         <label>          A given character string

Description
         This command defines a label to be used for a destination to which the process jumps to by using <GO> or <IF>.
         It can be used also for the name of a subroutine called by <CALL>.

         <label> cannot exist by itself. 
         <label> is valid for the entire program (globally).

Example
         GO:Skip
         PLAY:AIBO:Banzai_sit_C  //"Never reach this line."
         :Skip
         PLAY:AIBO:Banzai_sit_C  //"Skipped!"

---------------------------------------------------------------------------

Name
         GO - jumps the process to the specified label.

Format
         GO:<label>

Argument
         <label>          Label of the destination to which the process will jump to

Description
         This command jumps the process to the line with <label>.

         It is prohibited to use <GO> across subroutines or scopes. 
Using it in such a way would destroy the stack, and the program would run out of control. You may use it to break a loop structure.

         Refrain from using <GO> as much as possible.

Example
         GO:Skip
         PLAY:AIBO:Banzai_sit_C  //"Never reach this line."
         :Skip
         PLAY:AIBO:Banzai_sit_C  //"Skipped!"

---------------------------------------------------------------------------

Name
         IF - conditional test statement.

Format
         Format1
         IF:<v1>:<op>:<v2>:THEN
          THEN Block
         ELSE
          ELSE Block
         ENDIF

         Format2
         IF:<v1>:<op>:<v2>:CALL:<label>[:<argc>]

         Format3
         IF:<v1>:<op>:<v2>:BREAK

         Format4
         IF:<v1>:<op>:<v2>:<then>[:<else>]

Argument
         <v1>             Operand 1
         <op>             Comparison operator
         <v2>             Operand 2


         List of comparison operators 

             =            Equal to
             <>           Not equal to
             <            Less than
             <=           Less than or equal to
             >            Greater than
             >=           Greater than or equal to
             &            Bitwise logical AND
             |            Bitwise logical OR
             ^            Bitwise exclusive OR
             &&           Logical AND (The operand is handled as a Boolean value. 0 is false. Any other case is true.)
             ||           Logical OR (The operand is handled as a Boolean value. 0 is false. Any other case is true.)


         <label>          Label of a subroutine
         <argc>           The number of the arguments of a subroutine

         <then>           Label of the jump destination when conditions are met
         <else>           Label of the jump destination when conditions are not met

Description
         This command evaluates a conditional expression consisting of <v1>, <op> and <v2>, and to carry out processes in accordance with the results.

         In the case of Format 1:
         If the conditional express is true, the program executes <THEN Block>.
         If the conditional express is false, it executes <ELSE Block>.
         <ELSE~> and <ELSE Block~> can be omitted.
         Make sure to terminate the statement with ENDIF.

         In the case of Format 2:
         If the conditional expression is true, it calls the function <label>.
         For the arguments subsequent to <label>, refer to the description of CALL.

         In the case of Format 3:
         If the conditional expression is true, it executes BREAK.
         It is used for exiting a loop.
         For further details, refer to the description of BREAK.

         In the case of Format 4:
         If the conditional expression is true, it jumps the process to the <then> label.
         If the conditional expression is false, it jumps the process to the <else> label. 
         Refer to the note of GO. 
         Refrain from using this format as much as possible.

Example
         IF:x:=:0:THEN
           //"x is 0"
         ELSE
           //"x is not 0"
         ENDIF

---------------------------------------------------------------------------

Name
         SWITCH - branches the process. (Sets the context value)

Format
         SWITCH:<v>

Argument
         <v>              Variable names or constants

Description
         This command sets the value of <v> as a context value. 
It implements multi-way branching conditions together with CASE statements.

Example
         SWITCH:x
         CASE:1:PLAY:AIBO:Akubi_sit  //"x = 1"
         CASE:2:PLAY:AIBO:Akubi_sit  //"x = 2"
         CASE:2:PLAY:AIBO:Akubi_sit  //"(two)"
         CASE:3:PLAY:AIBO:Akubi_sit  //"x = 3"
         CASE:ELSE:PLAY:AIBO:Akubi_sit  //"x is not 1"
         CASE:ELSE:PLAY:AIBO:Akubi_sit  //"x is not 2"
         CASE:ELSE:PLAY:AIBO:Akubi_sit  //"x is not 3"

---------------------------------------------------------------------------

Name
         CSET - branches the process. (Sets the context value)

Format
         CSET:<v1>:<op>:<v2>:<v3>

Argument
         <v1>             Operand 1
         <op>             Comparison operator
         <v2>             Operand 2

         <v3>             Variable names or constants

Description
         This command evaluates the conditional expression consisting of <v1>, <op> and <v2>.  If the results of the evaluation turn out to be true, the program sets the value of <3> as the context value.

         CSET is a "skip" command.
When CSET appears in succession, the program ignores all CSET's except the first one that turns out to be true. 
It implements multi-way branching conditions together with CASE statements.

Example
         CSET:x:<:10:1
         CSET:x:<:20:2
         CSET:x:<:30:3
         CSET:x:<:40:4
         CSET:x:<:50:5
         CASE:1:PLAY:AIBO:Akubi_sit  //"x < 10"
         CASE:2:PLAY:AIBO:Akubi_sit  //"x < 20"
         CASE:3:PLAY:AIBO:Akubi_sit  //"x < 30"
         CASE:4:PLAY:AIBO:Akubi_sit  //"x < 40"
         CASE:5:PLAY:AIBO:Akubi_sit  //"x < 50"

---------------------------------------------------------------------------

Name
         CASE - branches the process.

Format
         CASE:<const>:<command>

         CASE:ELSE:<command>

Argument
         <const>          Context value (It must be a constant.)

         <command>        Given R-CODE command (excluding CASE)

Description
         This command executes <command> when the context value equals <const>.
You can specify CASE:ELSE at the end of the contiguous CASE statements as well.
If the context value does not equal <const> of any CASE statements, the program executes <command> of ELSE.

Example
         SWITCH:x
         CASE:1:PLAY:AIBO:Akubi_sit  //"x = 1"
         CASE:2:PLAY:AIBO:Akubi_sit  //"x = 2"
         CASE:2:PLAY:AIBO:Akubi_sit  //"(two)"
         CASE:3:PLAY:AIBO:Akubi_sit  //"x = 3"
         CASE:ELSE:PLAY:AIBO:Akubi_sit  //"x is not 1"
         CASE:ELSE:PLAY:AIBO:Akubi_sit  //"x is not 2"
         CASE:ELSE:PLAY:AIBO:Akubi_sit  //"x is not 3"

---------------------------------------------------------------------------

Name
         FOR - NEXT - constitutes a loop structure.

Format
         FOR:<var>:<from>:<to>[:<step>]
           commands
         NEXT

Argument
         <var>            Loop variable
         <from>           Start value
         <to>             End value
         <step>           Increment value

Description
         This command executes the command statements up to NEXT repeatedly by incrementing the value of a variable in steps of <step> from <from> to <to>.

Example
         FOR:i:1:10
           PLAY:AIBO:Akubi_sit
           WAIT
         NEXT

         FOR:i:10:1:-1
           PLAY:AIBO:Akubi_sit
           WAIT
         NEXT

---------------------------------------------------------------------------

Name
         WHILE - WEND - constitutes a loop structure.

Format
         WHILE:<v1>:<op>:<v2>
          commands
         WEND

Argument
         <v1>             Operand 1
         <op>             Comparison operator
         <v2>             Operand 2

Description
         This command evaluates the conditional expression consisting of <v1>, <op> and <v2>, and executes the command statements up to WEND repeatedly as far as the evaluation results turn out to be true.

Example
         SET:i:0
         WHILE:i:<:10
           PLAY:AIBO:Akubi_sit
           WAIT
         WEND

---------------------------------------------------------------------------

Name
         REPEAT - UNTIL - constitutes a loop structure.

Format
         REPEAT
          commands
         UNTIL:<v1>:<op>:<v2>

Argument
         <v1>             Operand 1
         <op>             Comparison operator
         <v2>             Operand 2

Description
         This command executes the command statements up to UNTIL repeatedly until the evaluation results turn out to be true.

         It executes the command statements at least once.

Example
         SET:i:0
         REPEAT
           PLAY:AIBO:Akubi_sit
           WAIT
         UNTIL:i:>=:10

---------------------------------------------------------------------------

Name
         DO - LOOP - constitutes a loop structure.

Format
         DO[:WHILE|UNTIL:<v1>:<op>:<v2>]
          commands
         LOOP[:WHILE|UNTIL:<v1>:<op>:<v2>]

Argument
         <v1>             Operand 1
         <op>             Comparison operator
         <v2>             Operand 2

Description
         This command executes the command statements between DO and LOOP repeatedly.

         You can specify a conditional expression to DO and LOOP.  When the condition is met, the program exits from the loop.

         In case that you specify WHILE, the loop continues while the value of a conditional expression remains true.
         In case that you specify UNTIL, the program exits from the loop when the value of a conditional expression becomes true.

         If you fail to specify a conditional expression to DO or LOOP, the program falls into an infinite loop.

Example

---------------------------------------------------------------------------

Name
         BREAK - breaks a loop structure.
Format
         BREAK[:<break_level>]


Argument
         <break_level>    This argument specifies the number of nests of the loop structure that you want to break out of.  
         The number should be a constant. 
         You cannot specify a variable <break_level>. 

         If no value is specified, the program reads it as 1.

Description
         This command exits from the currently running loop structure. 
You can use it for all loop structures in common.

Example
         FOR:i:1:100
           IF:i:>:10:BREAK
           PLAY:AIBO:Akubi_sit
           WAIT
         NEXT

---------------------------------------------------------------------------

Name
         CALL - calls a subroutine.

Format
         CALL:<label>[:<argc>]

Argument
         <label>          Label of a subroutine to call
         <argc>           The number of arguments PUSHed in advance

Description
         This command calls a subroutine with <label>. 
         This command allows you to push a given number of arguments onto the stack with the PUSH command and pop them from the stack. 
         You should specify to <argc> the number of arguments pushed onto the stack.

         When this command calls a subroutine, the previous context value is saved to the stack.  It is restored when the execution of RETURN brings back the program to its previous location.

Example
         CALL:sub1

         PUSH:10     // Argument1
         PUSH:200    // Argument2
         PUSH:3000   // Argument3
         CALL:sub2:3

---------------------------------------------------------------------------

Name
         ARG - fetches an argument of a subroutine.

Format
         ARG:<var>

Argument
         <var>            Variable name

Description
         This command fetches the value of the argument of a subroutine to the variable <var>. 
         The same number of arguments as the number that were pushed to the stack with PUSH must be fetched with ARG.
         The arguments should be fetched using the first-in, first-out basis of the order in which they were pushed to the stack.

         Note that the order of fetch by this command is not done on the first-in, last-out basis, even though it is common for a normal stacks.

Example
         Calling from:
         PUSH:10
         PUSH:200
         PUSH:3000
         CALL:sub
         ...

         Subroutine:
         :sub
         ARG:arg1    // arg1 <- 10
         ARG:arg2    // arg2 <- 200
         ARG:arg3    // arg3 <- 3000
         ...         // arg 1~3 are created as LOCAL variables.
                     // It is not necessary to declare them as LOCAL variables.

---------------------------------------------------------------------------

Name
         RETURN - returns the program from a subroutine.

Format
         RETURN[:<return_value>]

Argument
         <return_value>   Return value

Description
         This command returns the program from a subroutine.
         You can specify a return value with <return_value>.
         The calling source fetches a return value with POP.

Example
         Calling from:
         CALL:sub
         POP:rc     // A return value (123) is fetched to the variable rc.
         ...        // This is always required when you call a subroutine that returns a return value.

         Subroutine:
         :sub
         ...
         RETURN:123

---------------------------------------------------------------------------

Name
         RET - returns the program from a subroutine (Switching version of context values)

Format
         RET:<context>

Argument
         <context>        Context value

Description
         This command returns the program from a subroutine. 
         After the return from the subroutine, a context value is set to <context>.
         When the value of <context> is 0, the context value at the time of having called the subroutine is set there again.

Example
         Calling from:
         CALL:sub
         CASE:1:PLAY:AIBO:Akubi_sit  //"case 1..."
         CASE:2:PLAY:AIBO:Akubi_sit  //"case 2..."
         CASE:3:PLAY:AIBO:Akubi_sit  //"case 3..."
         ...

         Subroutine:
         :sub
         ...
         RET:1
         ...
         RET:2
         ...
         RET:3

---------------------------------------------------------------------------

Name
         ONCALL - registers/deletes an interrupt processing routine.

Format
         ONCALL:<v1>:<op>:<v2>:<label>[:<resume_type>:<resume_label>]

         ONCALL:<-n>

Argument
         <v1>             Operand 1
         <op>             Comparison operator
         <v2>             Operand 2

         <label>          Label of an interrupt processing routine

         <resume_type>    Type of return
         <resume_label>   Label of the destination of jump after return

         <-n>            The number of interrupt processing routines that should be registered/deleted

Description
         This command registers an interrupt processing routine that should be called when the condition based on <v1>, <op> and <v2> is met. 
         The method of specifying a condition is the same as that of IF.

         Return from an interrupt processing routine is done as follows.
         <resume_type>
           0  The program returns to the statement where the interrupt took place.
           1  It returns to the statement where the interrupt took place and then GOes to <resume_label>.
           2  It returns to the location of the ONCALL statement.
           3  It returns to the location of the ONCALL statement and then GOes to <resume_label>.
           4  It returns to the beginning of the program (all the stacks are cleared).
           5  It returns to the beginning of the program and then GOes to <resume_label>.

         In the cases of above (2) ~ (5), the ONCALL commands registered after the corresponding ONCALL are deleted.
         In the cases of (3) and (5), however, the ONCALL commands registered at the same level as the return location are stored.

         The evaluation of conditions is done for each execution of statements (one line of R-CODE).

         Nested interrupts are prohibited (ignored).

         ONCALL is affected nested subroutines. 
         ONCALL registered in a given subroutine is disabled once the program exits from that subroutine.


         Specifying <-n> deletes the "n" pieces of ONCALL's registered right before the specification.
         <-n> should be a negative number.

Example
         ONCALL:Leg_RF_sw:=:1:9000 
---------------------------------------------------------------------------

Name
         RESUME - returns the program from an interrupt routine.

Format
         RESUME

Argument
         None

Description
         This command returns the program from an interrupt routine.
It functions similarly to RETURN from a CALL.
You should not use RETURN to return the program from the execution of an interrupt routine. 
The returning location relies on <resume_type> of ONCALL.

Example
         RESUME

---------------------------------------------------------------------------

Name
         GLOBAL - declares a variable as a global variable.

Format
         GLOBAL:<var>[:<init_value>]

Argument
         <var>            Variable name
         <init_value>      Initial value

Description
         This command declares a global variable <var>. 
         When you specify <init_value> as a global variable, that value is set as an initial value.

         If you use a variable name not declared either as a global or local variable, the R-CODE system automatically generates a global variable with that particular name.

Example
         GLOBAL:x:0

---------------------------------------------------------------------------

Name
         LOCAL - declares a variable as a local variable.

Format
         LOCAL:<var>[:<init_value>]

Argument
         <var>            Variable name
         <init_value>      Initial value

Description
         This command declares a local variable <var>. 
         When you specify <init_value> as a local variable, that value is set as an initial value.

         A local variable is prepared on a stack. 
         When the execution of the program exits from a subroutine or a scope, the space for the local variable is released.

Example
         LOCAL:y:0

---------------------------------------------------------------------------

Name
         LET - assigns a value to a variable.
Format
         LET:<var>:<value>

Argument
         <var>            Variable name
         <value>          Value (a variable name or a constant)

Description
         This command assigns a value to a variable. 
         It does not have special functions like SET does.

Example
         LET:x:1

---------------------------------------------------------------------------

Name
         SET - assigns a value to a variable.

Format
         SET:<var>:<value>

         SET:COLOR:<color>

         SET:<joint>:<angle>

Argument
         <var>            Variable name
         <value>          Value (a variable name or a constant)

         <color>          Color name
                          ORANGE  
                          PINK    
                          YELLOW  
                          BLUE    
                          GREEN   

         <joint>          Joint name to be set
         <angle>          New angle


Description
         This command sets a value to a variable. 
         Some variables have the following special functions.

         Power            controls On/Off of the power supply of motors.

         Head_tilt        moves a joint to the specified angle.
         Head_pan         is mainly used for debugging.
         Head_roll        Note that no consideration is given to the
         Head_mouth       concurrent use of this command with PLAY/MOVE.
         Tail_1
         Tail_2
         Leg_RF_1
         Leg_RF_2
         Leg_RF_3
         Leg_LF_1
         Leg_LF_2
         Leg_LF_3
         Leg_RR_1
         Leg_RR_2
         Leg_RR_3
         Leg_LR_1
         Leg_LR_2
         Leg_LR_3

Example
         SET:Power:1

---------------------------------------------------------------------------


Name
         DEF:POSE - registers a pose.

Format
         DEF:POSE:<pose>
           <joint>:<angle>
           <joint>:<angle>
           ...
         END

         DEF:POSE:<pose>[:<N>]

Argument
         <pose>              Pose name to be registered to pose_list
         <joint>             Joint name
         <angle>             Angle


         <pose>              Characters of a pose name to register
         <N>                 The number of poses to register

Description
         This command registers the pose, which is taken by setting the angle specified with <angle> to the joint specified with <joint>, to pose_list. 
         You do not need to set all 18 joints. 
         You can complete the settings with END.

         You can register poses from <pose>1 to <pose> N all together with the use of <pose>:N.
         Assign 0 to <pose> to initialize it.  
         In this case, you do not need to state END.

Example
         DEF:POSE:pose1
           Head_pan:40
           Head_roll:50
           Leg_LF_1:90
         END

         DEF:POSE:p:10  // <- The poses from p1 to p10 are registered to pose_list.

---------------------------------------------------------------------------

Name
         DEF:MOVE - defines MOVE.

Format
         DEF:MOVE:<move>
           <time>:<pose1>
           <time>:<pose2>
           ...
         END

Argument
         <move>              Motion name to register
         <time>              Transition time from the current pose to <pose1>
         <pose1>             Name of a pose to take

Description
         This command registers <move>, with which AIBO takes the pose specified with <pose> within the time specified with <time>, to move_list. 
         You can complete the settings with END.

Example
         DEF:MOVE:move1
           1000:pose1
           1000:pose2
           1000:pose3
         END

---------------------------------------------------------------------------

Name
         POSE:APK - takes a pose.  

Format
         POSE:APK:<pose>[:<time>]

Argument
         <pose>              Pose name to take
         <time>              Transition time from the current pose to <pose>

Description
         This command finds the pose name, specified with <pose>, from pose_list and makes AIOB take that pose. 
         You can specify the transition time from the current pose to the specific one with <time>.

Example
         POSE:APK:pose1:5000

---------------------------------------------------------------------------

Name
         PLAY:APK - performs a motion.

Format
         PLAY:APK:<move>

Argument
         <move>              Name of a motion to perform

Description
         This command finds the motion name corresponding to an argument from move_list and makes AIBO perform that motion.

Example
         PLAY:APK:move1

---------------------------------------------------------------------------

Name
         SET_POSE - updates part of a pose.

Format
         SET_POSE:<pose>:<joint>:<angle>

Argument
         <pose>              Pose name to update
         <joint>             Joint name which angle is to be updated
         <angle>             New angle

Description
         This command updates the joint angle specified with <joint> of <pose> to <angle>.

Example
         SET_POSE:pose1:Head_pan:50 // <- Changes Head_pan of pose1 to a new angle of 50 degrees

---------------------------------------------------------------------------

Name
         SET_MOVE - updates part of a motion.  

Format
         SET_MOVE:<move>:<index>:<time>:<pose>

Argument
         <move>              Motion name to update
         <index>             Pose name to update
         <time>              New time
         <pose>              New pose

Description
         This command changes the pose referred to by pose number <index> of <move> to <pose> with <time>.

Example
         DEF:MOVE:move1
           1000:pose1
           1000:pose3
         END
         SET_MOVE:move1:1:5000:pose2 // <- To change 1000:pose3 to 5000:pose2

---------------------------------------------------------------------------

Name
         REC - records the joint angles of AIBO.

Format
         REC:POSE:<pose>[:<I>]

Argument
         <pose>              Pose name to record
         <I>

Description
         This command reads and records the joint angles of AIBO.
         When you specify <I>, this command records the current joint angles of AIBO to poseI where the number I is the pose number defined with DEF:POSE:<pose>:N.

Example
         REC:POSE:pose1

---------------------------------------------------------------------------

Name
         LOAD_POSE - loads a pose.

Format
         LOAD_POSE:<pose>

Argument
         <pose>              Pose name to load

Description
         This command loads <pose>.apk stored in OPEN-R\DATA\APK on the "Memory Stick" and adds it to pose_list.
When the loaded <pose>.apk has the pose name already defined in pose_list, it is overwritten.

Example
         LOAD_POSE:pose1

---------------------------------------------------------------------------

Name
         SAVE_POSE - saves a pose.

Format
         SAVE_POSE:<pose>

Argument
         <pose>              Pose name to save

Description
         This command saves a registered pose to OPEN-R\DATA\APK on the "Memory Stick" as <pose>.apk.

Example
         SAVE_POSE:pose1  // <- pose1 in this statement is saved as pose1.apk on the "Memory Stick".

---------------------------------------------------------------------------

Name
         LIMITTER - controls the limiter.  

Format
         SET:LIMMITER:ON/OFF

Argument
         None

Description
         This command controls the limiter.
Turning off the limiter allows AIBO to perform motions more quickly, but it has negative impacts such as additional loads to AIBO.

         When AIBO moves from the angle A to B in time "t", its momentum per unit of time is expressed as (B-A)/t.  If the limiter is turned on, however, the maximum value of its operating angle per unit of time is limited to a certain degree.  If the limiter is turned off for the transition from the above A to B, you can set a shorter time to "t".

Example
         SET:LIMITER:ON

---------------------------------------------------------------------------



[ List of R-CODE System Variables ]

         Head_tilt       Head: Angle of the first joint [degree]
         Head_pan        Head: Angle of the second joint [degree]
         Head_roll       Head: Angle of the third joint [degree]
         Head_mouth      Head: Angle of the mouth joint [degree]
         Tail_1          Tail: Angle of the first joint [degree]
         Tail_2          Tail: Angle of the second joint [degree]
         Leg_RF_1        Right-front leg: Angle of the first joint [degree]
         Leg_RF_2        Right-front leg: Angle of the second joint [degree]
         Leg_RF_3        Right-front leg: Angle of the third joint [degree]
         Leg_LF_1        Left-front leg: Angle of the first joint [degree]
         Leg_LF_2        Left-front leg: Angle of the second joint [degree]
         Leg_LF_3        Left-front leg: Angle of the third joint [degree]
         Leg_RR_1        Right-hind leg: Angle of the first joint [degree]

         Leg_RR_2        Right-hind leg: Angle of the second joint [degree]
         Leg_RR_3        Right-hind leg: Angle of the third joint [degree]
         Leg_LR_1        Left-hind leg: Angle of the first joint [degree]
         Leg_LR_2        Left-hind leg: Angle of the second joint [degree]
         Leg_LR_3        Left-hind leg: Angle of the third joint [degree]
         Head_sw         Head: Pressure sensor [10^-3Pa]
         Distance        Head: Obstacle sensor [mm]
         Leg_RF_sw       Right-front leg: Paw sensor [On:-1 Off:0]
         Leg_LF_sw       Left-front leg: Paw sensor [On:-1 Off:0]
         Leg_RR_sw       Right-hind leg: Paw sensor [On:-1 Off:0]
         Leg_LR_sw       Left-hind leg: Paw sensor [On:-1 Off:0]

         Gsensor_status  G sensor: Status 16bit flag (*3)
         Gsensor_roll    G sensor: Roll angle [degree]
         Gsensor_pitch   G sensor: Pitch angle [degree]
         Gsensor_yaw     G sensor: Yaw angle [degree]
         Cdt_npixel      Color sensor: The number of pixels [Pixels]
         Touch_head      Head touch sensor
         Touch_head_time  Head touch sensor: Length of time of the head's being pressed
         Touch_head_press    Head touch sensor: Average pressure
         Touch_RF        Right-front leg: Paw sensor to detect ON->OFF OFF->ON 
         Touch_LF        Left-front leg: Paw sensor to detect ON->OFF OFF->ON
         Touch_RR        Right-hind leg: Paw sensor to detect ON->OFF OFF->ON 
         Touch_LR        Left-hind leg: Paw sensor to detect ON->OFF OFF->ON 

         Tone_num        Tone detection 	Tone number
         Tone_level                  Tone level
         Tone_dir                    Direction of tone detection
         Melody_id       Melody detection 	Melody ID
         Melody_num                  The number of tones (1 to 3)
         Tone1_num                   Tone1 Tone number
         Tone1_level                 Tone1 Tone level
         Tone1_dir                   Tone1 Direction of the detected tone
         Tone2_num                   Tone2 Tone number
         Tone2_level                 Tone2 Tone level
         Tone2_dir                   Tone2 Direction of the detected tone
         Tone3_num                   Tone3 Tone number
         Tone3_level                 Tone3 Tone level
         Tone3_dir                   Tone3 Direction of the detected tone
         Sound_status    Sound detection: Status (*4)
         Sound_num                   Tone number
         Sound_level                 Tone level
         Sound_dir                   Direction of the detected tone

         Sound_busy      1: Playing back sound  0: No sound
         Light_busy      1: Lighting  0: No light

         Sound_volume    Default sound level at the time of sound playback 
         Light_repeat    Default number of lighting repetition at the time of PLAY:LIGHT

         Power           Power supply of the motor  0:OFF 1:ON

         Status          Normal status    *1
         Emergency       Emergency        *2

         Context         Context value
         Wait            The number of motions to wait for completion

         Trace           Trace level (reserved for a special tracer)
         Debug           Debug level (reserved for a special debugger)

         Clock           Clock (to be incremented by 1 every 32ms)

         Wait_mode       For system inspection  * Users are not allowed to use it.


   *1     Status: Meaning of each bit

           bit
           0x0001  VIBRATION_DETECT        Detection of vibration
           0x0002  KEY_SW                  Pause button on the chest
           0x0004  CONNECT_TO_STATION      Connection to a station
           0x0008  BATTERY_CHARGING        Charging of the battery
           0x0010  BATTERY_DISCHARGING     Discharging of the battery
           0x0020  CONNECT_TO_EX_POWER     Connection to the external power supply
           0x0040  MOTOR_POWER             Power supply of the motor
           0x0080  LOW_BATTERY             Recharging is required (warning!).
           0x0100  FULL_BATTERY            The battery is fully charged.
           0x0200  80_BATTERY              Remaining capacity of the battery: 80%
           0x0400  60_BATTERY              Remaining capacity of the battery: 60%
           0x0800  OVER_HEAT_40            Over-heated (40 degrees)

   *2     Emergency: Meaning of each bit

           bit
           0x0001  LOW_LOW_BATTERY         Remaining capacity of the battery: less than 20%
           0x0002  OVER_HEAT_RELEASE       Over-heated due to discharging (60 degree)
           0x0004  OVER_HEAT_CHARGE        Over-heated due to recharging (40 degree)
           0x0008  LOW_VOLTAGE             Low voltage
           0x0010  OVER_CURRENT            Over current (reserved)
           0x0020  FAN_STOP                Stop of the internal fan

   *3     Gsensor_status: Meaning of each bit

           bit     OMGsensor status
           0x0001  FALL_DOWN_FRONT         (Frontward) Fall-down
           0x0001  FALL_DOWN_RIGHT         (Rightward) Fall-down
           0x0001  FALL_DOWN_LEFT          (Leftward) Fall-down
           0x0001  FALL_DOWN_REAR          (Backward) Fall-down
           0x0002  HOLD_UP                 Holding-up
           0x0004  HOLD_DOWN               Holding-down
           0x0400  GET_UP                  Getting-up from a fall-down state
           0x0800  JOINT_DANGER            Pinch of joints
           0x1000  JOINT_GAIN_ENABLED      Gain On
           0x2000  JOINT_GAIN_DISABLED     Gain Off

   *4     Sound_status

           0       omtonePEAK              Tone with a peak
           1       omtoneNOPEAK            Tone without a peak
           2       omtoneNOPOWER           Low sound level
           3       omtoneCALC              Calculating
           4       omtoneOVERFLOW          Overflow


   ** Some sensor values always reflect the latest status, while some others are updated when an event takes place and are kept from that time on. 
In the latter case, the conditional test becomes true repeatedly depending on programming, and as a result, the same process may be repeated more than necessary.  In that case, use SET or AND to reset a sensor value and you can avoid this kind of a problem.


   *x  Sound cannot be detected for about 5 seconds right after the execution of PLAY:SOUND. 
This is because AIBO cannot carry out the playback and the detection of sound concurrently, nor detect the completion of the playback of sound precisely.  (It is the completion of the transmission of the sound data that AIBO can detect.)   






[ Quick Reference of R-CODE Operators ]



   Operator

         Operators carry out arithmetic operations and store the results to the variable <var>.

         <var>                    Variable name
         <value>                  Value (a variable name or a constant)

         ADD:<var>:<value>   <var> <- <var> + <value>   Addition
         SUB:<var>:<value>   <var> <- <var> - <value>   Subtraction
         MUL:<var>:<value>   <var> <- <var> * <value>   Multiplication
         DIV:<var>:<value>   <var> <- <var> / <value>   Division
         MOD:<var>:<value>   <var> <- <var> % <value>   Remainder

         AND:<var>:<value>   <var> <- <var> & <value>   Bitwise logical AND
         IOR:<var>:<value>   <var> <- <var> | <value>   Bitwise logical OR
         XOR:<var>:<value>   <var> <- <var> ^ <value>   Bitwise exclusive OR
         NOT:<var>:<value>   <var> <-       ~ <value>   Bitwise logical NOT

         LAND:<var>:<value>       <var> <- <var> AND <value>   Logical AND
         LIOR:<var>:<value>       <var> <- <var> OR  <value>   Logical OR
         LNOT:<var>:<value>       <var> <-       NOT <value>   Logical NOT

         RND:<var>:<from>:<to>    <var> <- Value of a uniform random number in the range between <from> and <to>


         In addition to the above operators, the following stack operators are provided. 
They pop operands from the stack and push the results onto the stack.

         ADD             <push> <- <pop1> + <pop2>   Addition
         SUB             <push> <- <pop1> - <pop2>   Subtraction
         MUL             <push> <- <pop1> * <pop2>   Multiplication
         DIV             <push> <- <pop1> / <pop2>   Division
         MOD             <push> <- <pop1> % <pop2>   Remainder

         AND             <push> <- <pop1> & <pop2>   Bitwise logical AND
         IOR             <push> <- <pop1> | <pop2>   Bitwise logical OR
         XOR             <push> <- <pop1> ^ <pop2>   Bitwise exclusive OR
         NOT             <push> <-        ~ <pop2>   Bitwise logical NOT

         LAND            <push> <- <pop1> AND <pop2> Logical AND
         LIOR            <push> <- <pop1> OR  <pop2> Logical OR
         LNOT            <push> <-        NOT <pop2> Logical NOT

         EQ              <push> <- <pop1> == <pop2>  Equal to
         NE              <push> <- <pop1> <> <pop2>  Not equal to
         LT              <push> <- <pop1> <  <pop2>  Less than
         LE              <push> <- <pop1> <= <pop2>  Less than or equal to
         GT              <push> <- <pop1> >  <pop2>  Greater than
         GE              <push> <- <pop1> >= <pop2>  Greater than or equal to

         RND:<from>:<to>   <push> <- Values of uniform random numbers in the range between <from> and <to>
         RND:<to>          <push> <- Values of uniform random numbers in the range from 0 to <to>


   Stack

         PUSH:<var>     pushes a variable value or a constant onto the stack.

         POP[:<var>]    pops a value from the stack to a variable.
                        If <var> is not specified, the fetched value is discarded.

         DUP            copies the top data element of the stack and pushes it back onto the stack.

         JT:<label>     pops a value from the stack. If the value is true, the program jumps to <label>.

         JF:<label>     pops a value from the stack. If the value is false, the program jumps to <label>.


         Note: Stack operations across subroutines or scopes are not possible.




[ List of Semantics of AIBO Performer Kit ]
This list allows you to edit motions with AIBO Performer Kit.

Semantics : Name callable with the R-CODE system
Pose      : Posture for starting and finishing a motion
Sound     : Sound played back in sync with a motion


Calling method on the R-CODE system

PLAY:ESC:P1P1
         ^^^^
         The following are the descriptions of semantics.


Semantics           Pose           Sound
P1P1               Sitting        pero1ttp.mid
P1P2               Sitting        bow1_ttp.wav
P1P3               Sleeping       scrt3ppp.wav
P1P4               Standing       nobi1ddp.mid
P1P5               Standing       gari1ddp.mid
P1I1               Standing       look1ddp.mid
P1I2               Standing       bow1_ddp.wav
P1I3               Standing       mark1ddp.wav
P1I4               Sleeping       yawn5ppp.wav
P1I5               Sleeping       tail4ppp.mid
P1I6               Sitting        yawn1xxp.wav
P1I7               Sitting        dig1_ttp.mid
P1I8               Sitting        tilt1ttp.mid
P1I9               Sleeping       gari1ppp.mid
P2P1               Sitting        bye1_ddp.wav
P2P2               Sitting        strg1ttp.wav
P2P3               Sleeping       nobi2ppp.mid
P2P4               Sleeping       flwr2ppp.mid
P2P5               Standing       bend1ddp.mid
P2I1               Standing       yura1ddp.mid
P2I2               Standing       swng1ddp.mid
P2I3               Standing       swng2ddp.mid
P2I4               Sleeping       flwr1ppp.mid
P2I5               Sitting        kyor1ttp.mid
P2I6               Sitting        pose1ttp.mid
P2I7               Sitting        yawn2xxp.wav
P3P1               Sitting        kiss1ttp.wav
P3P2               Sitting        banz1ttp.wav
P3P3               Sleeping       thnk1ppp.mid
P3P4               Sleeping       find1ppp.mid
P3P5               Standing       smel1ddp.wav
P3I1               Standing       tilt2ddp.mid
P3I2               Sleeping       sigh1ppp.wav
P3I3               Sleeping       yawn4xxp.wav
P3I4               Sleeping       bata1ppp.wav
P3I5               Sitting        exec1ttp.mid
P3I6               Sitting        what1ttp.mid
P3I7               Sitting        yawn3xxp.wav
P4P1               Sitting        usr#1.wav
P4P2               Sitting        usr#2.wav
P4P3               Sleeping       usr#3.wav
P4P4               Standing       usr#4.wav
P4P5               Standing       usr#5.wav
P4I1               Standing       usrd#1.wav
P4I2               Standing       usrd#2.wav
P4I3               Sleeping       usrp#1.wav
P4I4               Sleeping       usrp#2.wav
P4I5               Sitting        usrt#1.wav
P4I6               Sitting        usrt#2.wav
G_L1               Sitting        lose1ttg.wav
G_L2               Sitting        lose2ttg.wav
G_L3               Sitting        lose3ttg.wav
G_W1               Sitting        win1_ttg.wav
G_W2               Sitting        win2_ttg.wav
G_W3               Sitting        win3_ttg.wav
AAN1               Sitting        kyor4ttx.mid
AAN2               Sitting        nobi6ttx.mid
AAN3               Sitting        Not Available
AAN4               Sleeping       Not Available
AAN5               Sitting        srch1ttx.mid
AAN6               Sleeping       kyor5ppx.mid
AAN7               Standing       kyor6ddx.mid
AAN8               Standing       tilt3ddx.mid
AAP1               Sitting        ltch1ttx.mid
AAP2               Sleeping       ltch1ppx.mid
AAP3               Standing       ltch1ddx.mid
AAP4               Sitting        roll1ttx.mid
AAP5               Standing       roll1ddx.mid
AAP6               Sitting        stch1ttx.mid
AAP7               Sleeping       stch1ppx.mid
AAP8               Standing       stch1ddx.mid
AAJ1               Standing       joy6_dda.mid
AAJ2               Standing       joy7_ddy.mid
AAF1               Standing       fer4_dda.mid
AAF2               Sleeping       fer5_ppa.mid
AAD1               Sitting        dsg4_tta.mid
AAD2               Standing       dsg5_dda.mid
AAD3               Sitting        dsg5_tty.mid
AYJ1               Standing       joy6_ddy.mid
AYW1               Sleeping       sup5_ppa.mid
AYW2               Standing       sup4_ddy.mid
AYW3               Standing       sup5_ddy.mid
AYS1               Standing       sad5_ddy.mid
AYF1               Standing       fer5_ddy.mid
AYD1               Sleeping       dsg5_ppy.mid
AYD2               Sitting        dsg5_ttc.mid



[ ESC File ]
Three types of data, "motion", "sound" and "light," are associated with one command in the ESC.CFG file, so all three can be executed with one command.

A part of \OPEN-R\APP\CONF\ESC.CFG
----------------------------------------------------
2715
GET_STPOS	motion	oAll:slp_stasm	NULL
OFF_STPOS	motion	oAll:stasm_slp	NULL
9AMAZING	sound	amz1_xxx	100
9JITA_KYORO	motion	oAll:JitaKyoro_fall	NULL
9JITA_KYORO	sound	risebxxx	100
9JITA_LEG	motion	oAll:JitaLeg_fall	NULL
9JITA_LEG	sound	risefxxx	100
9JITA_PAKU1	motion	oAll:JitaPaku1_fall	NULL
9JITA_PAKU1	sound	riselxxx	100
9JITA_PAKU2	motion	oAll:JitaPaku2_fall	NULL
9JITA_PAKU2	sound	riserxxx	100
9RISE_FRONT	motion	oAll:GetupF_fall_std	NULL
9RISE_LEFT	motion	oAll:GetupL_fall_std	NULL
9RISE_READY	motion	oAll:E_Stop	NULL
9RISE_REAR	motion	oAll:GetupB_fall_std	NULL
9RISE_RIGHT	motion	oAll:GetupR_fall_std	NULL
9SQUEEZE	sound	sqz1_xxx	100
  .
  .
  .
  .
  .
----------------------------------------------------

2715 on the first line indicates the total number of lines that are after the first line in this file (total number of lines minus one).

Association is done from the second line on.

9AMAZING	sound	amz1_xxx	100
    a            b       c

a ESC name (a unique name)
b Grouping consisting of a patterns of "motion", "sound" and "light"
c The definition of "c" and the subsequent portion varies in its meaning depending on b.

    In the case of "sound": Sound name

                     Sound volume (normally 100)

    In the case of "motion": Region: Motion name
                     Region includes the following:
                       oAll: Motion of the whole body
                       oLegs: Motion of the 4 legs
                       oTail: Motion of the tail
                       oHead: Motion of the head

       Argument of motion (NULL should be specified for a normal motion.)

    In the case of "light": Name of LED light pattern
                     The number of repetitions




[ Motion Definition File ]
The Motion Definition File includes the files for the head, the 4 legs, the tail and the whole body.

They are grouped into the following 6 types:
head_XX.cfg  <-- List of head motions
legs_XX.cfg  <-- List of 4-leg motions
tail_XX.cfg  <-- List of tail motions
monet_XX.cfg <-- List of whole body motions

XXXX_00.cfg <-- File listing motions defined externally
                 The motions defined externally are those which data is defined in a separate file (*.oda).
XXXX_01.cfg <-- File listing motions defined internally
                 The motions defined internally are motions generated and performed by the program.

File Path
\OPEN-R\SONY\CONF\

A part of head_01.cfg
----------------------------------------------------
oAll   <-- a
136    <-- b
Akubi_sit	oSitting	oSitting	dt#1_n   <-- c
Akubi_sit_C	oSitting	oSitting	sitpc001
Akubi_sit_D	oSitting	oSitting	dt#1
Akubi_sit3	oSitting3	oSitting3	ct3#321_n
  .
  .
  .
----------------------------------------------------

a Indicates the region name.
    oHead: Head
    oLegs: 4 legs
    oTail: Tail
    oAll : Whole body

b The number of valid data

c Definition of motions

    Akubi_sit	oSitting	oSitting	dt#1_n
    (a)          (b)         (c)         (d)

    (a) Motion definition name
    (b) Starting pose
    (c) Ending pose
    (d) Motion name



[ Musical Scale Recognition File ]
The musical scale recognizable with the R-CODE system is defined in the TD.CFG file.

Location on the "Memory Stick" where the musical scale is placed:
\OPEN-R\SONY\CONF\TD.CFG

A part of TD.CFG 
---------------------------
CDE
C#D#F
DEF#
D#FG
EF#G#
FGA
F#G#A#
GAB
CED
C#FD#
---------------------------

Contents

C: do
D: re
E: me 
F: fa
G: so
A: la
B: ti
#: Sharp
~: Flat

When AIBO recognizes the musical scale of do, re and me (CDE), the line number where the musical scale of do, re and me (CDE) is defined in the TD.CFG file, 1 in this example, is assigned to the R-CODE system variable Melody_id.

For Melody_id, refer to the separate text file:  Musical Scale Recognition List.

Edit - History - Print - Recent Changes - Search - Site Terms of Use
Page last modified on February 05, 2006, at 04:30 PM CST