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

Aibo General

Aibo Development

Wiki Help

Aibo Links

R-Code » ERS 210/220/31x Official Reference
===========================================================================

        R-CODE Ver1.2

        Copyright (C) 2002 Sony Corporation
        All Rights Reserved.

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


[ R-CODE Coding Conventions ]
[ List of R-CODE Commands by Function ]
[ Alphabetical List of R-CODE Commands ]

[ Command Reference ]

[ R-CODE Operator Quick Reference ]
[ List of R-CODE System Variables ]
        [Common to All Models]
        [ERS-210]
        [ERS-310]
        [ERS-220]
        [Voice ID List]
        [AiboSound ID List]
        [AiboTone ID List]

 [WirelessLAN communication]



[ R-CODE Coding Conventions ]

  1) A line may be up to 127 bytes long (total, including comments and a newline character).

  2) R-CODE commands consist of words separated by colons (:).

        Word1:Word2:Word3

  3) Only alphanumeric Ascii characters and underscores (_) may be used in words.
     NOTE: other symbols have special meanings.

  4) Space and Tab characters at the heads of lines are ignored (for indenting)

  5) Lines beginning with a colon (:) are considered to be label rows.

        :Label

  6) Lines whose first character is not an alphanumeric Ascii character or colon (:) are treated as comment lines, and ignored.

  7) If a double slash (//) is contained in a line, everything thereafter in that line is treated as a comment, and ignored.

        Word1:Word2:Word3  // comment

  8) Since colons (:), spaces, tabs, and newline characters are treated as separators, they cannot be used in names and the like.
     In order to include these characters in format strings and the like, wrap the entire string in double quotes ("").

        PRINT:"x = %d":x

  9) Words starting with the following characters are treated as numbers: + - 0 1 2 3 4 5 6 7 8 9
     Numbers whose first two characters are 0x or 0X are treated as hexadecimal numbers.
     Numbers whose first two characters are 0o or 0O are treated as octal numbers.
     Numbers whose first two characters are 0b or 0B are treated as binary numbers.

        SET:x:0x03FC
        SET:y:0o0777
        SET:z:0b00001111

 10) Words in ALL-CAPS are reserved for R-CODE system use.
     Please do not use ALL-CAPS for user variable names, etc.

        BAD -- SET:USER1:0 (could cause future conflicts with words reserved by the R-CODE system)
        GOOD -- SET:user1:0 (use of all lowercase variable names recommended)
        CAUTION -- SET:User1:0 (make sure capitalized names do not overlap with system variables)





[ List of R-CODE Commands by Function ]

Control

  EDIT             Load program
  END              Program load termination
  RUN              Begin execution
  EXIT             Terminate execution
  HALT             Terminate and shutdown
  INIT             Initialize
  !                Break (force stop)

Actions

  PLAY             Play action
  STOP             Normal stop
  QUIT             Emergency stop
  WAIT             Wait
  SYNC             Synchronize
  NONE             No operation

Printing

  PRINT            Print

Control Structures

  :                Label
  GO               Jump
  IF               Conditional test
  SWITCH           Multiway-branching (Context value setting)
  CSET             Multiway-branching (Context value setting)
  CASE             Multiway-branching (Conditional execution)
  FOR              FOR loop
  NEXT             FOR loop termination
  WHILE            WHILE loop
  WEND             WHILE loop termination
  REPEAT           REPEAT loop
  UNTIL            REPEAT loop termination
  DO               DO loop
  LOOP             DO loop termination
  BREAK            Break out of loop
  CALL             Call subroutine
  ARG              Retrieve subroutine argument
  RETURN           Return from subroutine
  RET              Return from subroutine (context version)
  ONCALL           Register interrupt routine
  RESUME           Return from interrupt routine

Variables

  GLOBAL           Global variable declaration
  LOCAL            Local variable declaration
  LET              Assign (simple assignment)
  SET              Assign (with special functions)
  GET              Refer (for debugging)
  CLR              Clear sensor variable

  VSAVE            Save variable value
  VLOAD            Load variable value
  VDUMP            Display variable value

Operators

  ADD              Add
  SUB              Subtract
  MUL              Multiply
  DIV              Divide
  MOD              Remainder
  AND              Logical product
  IOR              Inclusive OR
  XOR              Exclusive OR
  NOT              Negation
  LAND             Logical product (Boolean operator)
  LIOR             Inclusive OR (Boolean operator)
  LNOT             Negation (Boolean operator)
  EQ               Equal
  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 Operations

  PUSH             Add element to stack
  POP              Remove element from stack
  DUP              Copy stack top
  JT               Jump if stack top is true
  JF               Jump if stack top is false





[ Alphabetical List of R-CODE Commands ]

  !                Break (force stop)
  :                Label
  ADD              Add
  AND              Logical product
  ARG              Retrieve subroutine argument
  BREAK            Break out of loop
  CALL             Call subroutine
  CASE             Multiway-branching (Conditional execution)
  CLR              Clear sensor variable
  CSET             Multiway-branching (Context value setting)
  DIV              Divide
  DO               DO loop
  DUP              Copy stack top
  EDIT             Load program
  END              Program load end point
  EQ               Equal
  EXIT             Terminate execution
  FOR              FOR loop
  GE               Greater than or equal to
  GET              Refer (for debugging)
  GLOBAL           Global variable declaration
  GO               Jump
  GT               Greater than
  HALT             Terminate and shutdown
  IF               Conditional test
  INIT             Initialize
  IOR              Logical sum
  JF               Jump if stack top is false
  JT               Jump if stack top is true
  LAND             Logical product (Boolean operator)
  LE               Less than or equal to
  LET              Assign (simple assignment)
  LIOR             Inclusive OR (Boolean operator)
  LNOT             Negation (Boolean operator)
  LOCAL            Local variable declaration
  LOOP             DO loop termination
  LT               Less than
  MOD              Remaider
  MUL              Multiply
  NE               Not equal to
  NEXT             FOR loop end point
  NONE             No operation
  NOT              Negation
  ONCALL           Register interrupt routine
  PLAY             Play action
  POP              Remove element from stack
  PRINT            Print
  PUSH             Add element to stack
  QUIT             Emergency stop
  REPEAT           REPEAT loop
  RESUME           Return from interrupt routine
  RET              Return from subroutine (context version)
  RETURN           Return from subroutine
  RND              Random number
  RUN              Begin execution
  SET              Assign (with special functions)
  STOP             Normal stop
  SUB              Subtract
  SWITCH           Multiway-branching (Context value setting)
  SYNC             Synchronize
  UNTIL            REPEAT loop termination
  VDUMP            Display variable value
  VLOAD            Load variable value
  VSAVE            Save variable value
  WAIT             Wait
  WEND             WHILE loop end point
  WHILE            WHILE loop
  XOR              Exclusive OR



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

Name
        EDIT - Load program (Transfer program from PC to AIBO) 

Format
        EDIT
        < program >
        END

Arguments
        None

Description
        Loads R-CODE program from EDIT to END into memory.
        Any program already existing in memory is deleted. 

Example
        EDIT
        FOR:i:1:10
          PLAY:ACTION:xxx
          WAIT
        NEXT
        EXIT
        END

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

Name
        END - Program load termination

Format
        EDIT
        < program >
        END

Arguments
        None

Description
        See description for EDIT.

Example
        EDIT
        FOR:i:1:10
          PLAY:ACTION:xxx
          WAIT
        NEXT
        EXIT
        END

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

Name
        RUN - Execute program

Format
        RUN

Arguments
        None

Description
        Begins execution of program currently in memory.

Example
        RUN

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

Name
        EXIT - Terminate program

Format
        EXIT

Arguments
        None

Description
        Halts program execution.

Example
        EDIT
        FOR:i:1:10
          PLAY:ACTION:xxx
          WAIT
        NEXT
        EXIT
        END

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

Name
        HALT - Halt program / shut down AIBO

Format
        HALT

Arguments
        None

Description
        Halt currently running program, and shut down AIBO.
        Shutdown takes several seconds.

Example
        EDIT
        FOR:i:1:10
          PLAY:ACTION:xxx
          WAIT
        NEXT
        HALT
        END

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

Name
        INIT - initialize R-CODE

Format
        INIT:<init_level>

Arguments
        <init_level>        See description

Description
        INIT:0  Initialize whole R-CODE system.
                This is performed automatically at startup.
                This is for system use only. Do not use this command in your R-code.

        INIT:1  Enter debug mode.
                For R-CODE Debugger (currently being developed separately)
                Do not use this command in your R-code.

        INIT:2  Initialize dictionary and variable table to startup values.
        INIT:3  Initialize at the time of WLAN connection.
                This is performed automatically upon WLAN connection.
                Optional second argument specifies the machine ID (AiboId). 
                Do not use this command in your R-code.

        INIT:4  WLAN Disconnect notification (Rcomm->RMain)
        INIT:9  Shutdown & Reboot

Example
        INIT    (same as INIT:0)
        INIT:2

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

Name
!                Break (force stop)

Format
        !        Conduct emergency stop, and halt program execution.
        !!       Conduct normal stop, and halt program execution.
        !!!      Conduct emergency stop, halt program execution, and initialize environment.

Arguments
        None

Description
        Forces program execution to halt.
        For control from AMS and other PC applications.

Example
        !

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

Name
        PLAY -- Play action

Format
        General format
        PLAY:<type>:<name>[:<arg1>:<arg2>:<arg3>]

        PLAY:ACTION:<action>[:<arg1>:<arg2>:<arg3>]

Arguments

        <action> -- Action name

        <arg1 - 3> -- Optional arguments (vary depending on Action)
                      Constant value or Variable name

Description
        Plays action specified by <action>.
        The action names that can be specified by <action> are defined in Action.cfg.

        Checks whether the current posture is that of the start of the action to be played.
        If it is not the initial posture, AIBO automatically transitions to the starting posture.
        The <action> will be played once AIBO is in the starting posture.

Argument Pattern
        <horizontal angle>:<distance> // WALK, KICK, TOUCH, etc.
        <horizontal angle> // TURN, etc.
        <horizontal angle>:<vertical angle> // MOVE_HEAD, etc.
        <TARGET> // SEARCH, etc.

        Angle unit is degrees
        Distance unit is millimeters

        Currently, only PINK_BALL can be specified as <TARGET>.

Example
        PLAY:ACTION:STAND

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

Name
        STOP - Normal stop

Format
        STOP

Arguments
        None

Description
        Normal stop of action.
        Discards all actions remaining in the queue.
        If an action is currently being played, stops after that action is completed.

Example
        STOP

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

Name
        QUIT -- Emergency stop

Format
        QUIT

Arguments
        None

Description
        Emergency stop of action.
        Discards all actions remaining in the queue.
        Immediately halts operation, including any action currently being performed.

        Note: If QUIT is used, the posture is reset to an undefined state.

Example
        QUIT

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

Name
        WAIT - Wait until end of action (synchronize)

Format
        WAIT         Wait until the end of the preceding action.

        WAIT:<ms>    Wait specified amount of time.

        WAIT:<part>  Wait until the specified part finishes its action.

Arguments
        <ms>         milliseconds  [1 - 30000]   Note: resolution is 32 ms

        <part>       One of the following (For ERS-210)

                MOTION_ALL           All motions
                MOTION_HEAD          Head motion
                MOTION_LEG           Leg motion
                MOTION_TAIL          Tail motion
                MOTION_MOUTH         Chin motion
                MOTION_EAR           Ear motion
                SOUND_ALL            All sounds (including SOUND_SPK)
                SOUND_SPK            Sounds processed by SP.BIN
                LED_ALL              All lights
                LED_FACE             Face (eye) lights
                LED_MODE             Mode lights
                LED_TAIL             Tail lights

Description
        Waits until the end of the preceding action that is being executed.
        Temporarily halts program execution.

        WAIT has no effect in a state where there is nothing to wait for.

        If <ms> is specified, processing is suspended for just the specified amount of time.

        If <part> is specified, processing is suspended until the specified part finishes its action/playback.

Example
        WAIT
        WAIT:1000
        WAIT:MOTION_HEAD

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

Name
        SYNC - External synchronization

Format
        SYNC

Arguments
        None

Description
        Executing SYNC during program execution pauses the program, and goes into standby for input.
        Processing restarts when the "SYNC" command string is sent.

Example
        SYNC

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

Name
        NONE        No operation

Format
        NONE

Arguments
        None

Description
        A "no-operation" statement.
        Processing immediately continues on the next line.

Example
        NONE

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

Name
        PRINT - Print (for online debugging)

Format
        PRINT:<format>[:<var1>:<var2>:<var3>:<var4>:<var5>]

Arguments
        <format>        Format string

                        %d Decimal notation
                        %x Hexadecimal notation

        <var1> - <var5> Variable name.

Description
        Display messages using method similar to the C printf() command. 

        If <format> includes spaces or tabs, enclose the entire <format> string in double quotes ("").

Example
        PRINT:"x=%d y=%d":x:y

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

Name
        :<label> - Label

Format
        :<label>

Arguments
        <label> arbitrary string

Description
        Defines a label used as destination for GO and IF statements.
        Also used to name subroutines called with CALL command.

        Labels cannot exist independently.
        Execution flow continues on the line immediately following the label.
        Labels have global scope (they range over the entire program).

Example
        GO:Skip
        PRINT:"Never reach this line."
        :Skip
        PRINT:"Skipped!"

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

Name
        GO - Jump

Format
        GO:<label>

Arguments
        <label>         Jump destination label

Description
        Go to line with <label> attached.

        Go statements cannot range outside of subroutine or scope.
        Doing so will cause a stack overflow.
        There is no problem with using a GO statement to break out of a loop structure.

        Try to keep the use of GO statements to a minimum.

Example
        GO:Skip
        PRINT:"Never reach this line."
        :Skip
        PRINT:"Skipped!"

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

Name
        IF - Conditional test

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

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

        Format 3
        IF:<v1>:<op>:<v2>:BREAK

        Format 4
        IF:<v1>:<op>:<v2>:<then>[:<else>]

Arguments
        <v1>                Operand 1
        <op>                Relational operator
        <v2>                Operand 2


        List of relational operators

        =         Equal
        ==        Equal
        <>        Not equal to
        !=        Not equal to
        <         Less than
        <=        Less than or equal to
        >         Greater than
        >=        Greater than or equal to
        &         Bitwise AND (logical multiplication)
        |         Bitwise OR (logical addition)
        ^         Bitwise exclusive OR
        &&        AND/logical multiplication (operands treated as Boolean values: 0 treated as FALSE / other than 0 treated as TRUE)
        ||        OR/logical addition (operands treated as Boolean values: 0 treated as FALSE / other than 0 treated as TRUE)


        <label>   Subroutine label
        <argc>    Number of subroutine arguments

        <then>    Jump destination if condition satisfied
        <else>    Jump destination if condition not satisfied

Description
        Evaluates expression of the form <v1> <op> <v2> and performs processing
        according to the results.

        In case of format 1:
        If expression is true, execute THEN Block.
        If expression is false, execute ELSE Block.
        ELSE -- ELSE Block -- can be omitted
        Always be sure to terminate with ENDIF.

        In case of format 2:
        If expression is true, CALL function <label>.
        See the description for CALL for arguments after <label>.

        In case of format 3:
        If expression is true, execute BREAK.
        Used to break out of loops.
        For details, see the description for BREAK.

        In case of format 4:
        If expression is true, GO to <then> label.
        If expression is false, GO to <else> label.
        Please see notes for GO.
        Avoid this format as much as possible.

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

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

Name
        SWITCH - Multi-branching (Context value setting)

Format
        SWITCH:<v>

Arguments
        <v>       Variable name or constant

Description
        Set context value to <v>

        Combine with CASE statements to create multi-branching conditions.

Example
        SWITCH:x
        CASE:1:PRINT:"x = 1"
        CASE:2:PRINT:"x = 2"
        CASE:2:PRINT:"(two)"
        CASE:3:PRINT:"x = 3"
        CASE:ELSE:PRINT:"x is not 1"
        CASE:ELSE:PRINT:"x is not 2"
        CASE:ELSE:PRINT:"x is not 3"

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

Name
        CSET - Multi-branching (Context value setting)

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

Arguments
        <v1>      Operand 1
        <op>      Comparison operator
        <v2>      Operand 2
        <v3>      Variable name or constant

Description
        Evaluates expression of the form <v1> <op> <v2> and if true,
        set context value to <v3>.

        CSET is a 'skip' command.
        If several contiguous CSETs appear, all CSETs after the first one that is evaluated as true are ignored.

        Combine with CASE statements to create multi-branching conditions.

Example
        CSET:x:<:10:1
        CSET:x:<:20:2
        CSET:x:<:30:3
        CSET:x:<:40:4
        CSET:x:<:50:5
        CASE:1:PRINT:"x < 10"
        CASE:2:PRINT:"x < 20"
        CASE:3:PRINT:"x < 30"
        CASE:4:PRINT:"x < 40"
        CASE:5:PRINT:"x < 50"

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

Name
        CASE -- Multi-branching (Conditional execution)

Format
        CASE:<const>:<command>

        CASE:ELSE:<command>

Arguments
        <const> Context value (must be constant)

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

Description
        If the context value is equal to <const>, execute <command>.

        Also possible to add CASE:ELSE at the end of a series of CASE statements.
        If the context is not equal to any of the CASE constants, the ELSE <command>
        is executed.

Example
        SWITCH:x
        CASE:1:PRINT:"x = 1"
        CASE:2:PRINT:"x = 2"
        CASE:2:PRINT:"(two)"
        CASE:3:PRINT:"x = 3"
        CASE:ELSE:PRINT:"x is not 1"
        CASE:ELSE:PRINT:"x is not 2"
        CASE:ELSE:PRINT:"x is not 3"

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

Name
        FOR...NEXT - Loop structure

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

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

Description
        Repeats -- commands -- until NEXT while incrementing/decrementing
        variable <var> from <from> to <to>, in steps of <step>.

Example
        FOR:i:1:10
          PRINT:"i=%d":i
        NEXT

        FOR:i:10:1:-1
          PRINT:"i=%d":i
        NEXT

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

Name
        WHILE...WEND - Loop Structure

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

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

Description
        Evaluates expression of the form <v1> <op> <v2> and while true,
        repeatedly executes the -- commands -- up to the WEND statement.

Example
        SET:i:0
        WHILE:i:<:10
          PRINT:"i=%d":i
        WEND

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

Name
        REPEAT...UNTIL - Loop structure

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

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

Description
        Executes the -- commands -- up to the UNTIL statement, until the
        conditional expression <v1> <op> <v2> is true.

        The -- command -- block is always executed at least once.

Example
        SET:i:0
        REPEAT
          PRINT:"i=%d":i
        UNTIL:i:>=:10

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

Name
        DO...LOOP - Loop structure

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

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

Description
        Repeatedly executes -- command -- block between DO and LOOP.

        It is possible to specify a conditional expression for DO and LOOP. 
        Breaks out of the loop when either of the conditions is satisfied. 

        If WHILE is specified, continues to execute the loop while the conditional expression is true.
        If UNTIL is specified, continues to execute the loop until the conditional expression is true.

        If no condition is specified for either DO or LOOP, becomes an endless loop.

Example

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

Name
        BREAK - Break out of loop structure
Format
        BREAK[:<break_level>]

Arguments
        <break_level>   Specifies level of nesting of loop structure to break out of.
        Must be a constant value.
        Variables cannot be specified.
        Default value is 1.

Description
        Breaks out of the loop currently being executed.
        Can be used in the same way for all loop structures.

Example
        FOR:i:1:100
          IF:i:>:10:BREAK
          PRINT:"i=%d":i
        NEXT

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

Name
        CALL - Call subroutine

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

Arguments
        <label>   Subroutine label to be called
        <argc>    Number of previously PUSHed arguments

Description
        Calls subroutine <label>.
        Possible to pass an arbitrary number of arguments by placing them beforehand 
        on the stack using the PUSH commands.
        <argc> specifies the number of variables PUSHed onto the stack.

        On calling a subroutine, the current context value is PUSHed onto the stack. 
        It is restored when RETURN brings the program back to its initial location.

Example
        CALL:sub1

        PUSH:10     // argument 1
        PUSH:200    // argument 2
        PUSH:3000   // argument 3
        CALL:sub2:3

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

Name
        ARG - Retrieve subroutine argument

Format
        ARG:<var>

Arguments
        <var>       Variable name

Description
        Extracts value of subroutine argument into variable <var>.
        The same number of arguments must be retrieved as were PUSHed.
        The order in which arguments are retrieved is first-in-first-out.
        Note that the order is not first-in-last-out, like a normal stack.

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

        Subroutine:
        :sub
        ARG:arg1  // arg1 <- 10
        ARG:arg2  // arg2 <- 200
        ARG:arg3  // arg3 <- 3000
        ...   // arg1 - 3 are provided for use as local variables.
        // There is no need for separate LOCAL declarations

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

Name
        RETURN - Return from subroutine

Format
        RETURN[:<return_value>]

Arguments
        <return_value>  Return value

Description
        Returns from subroutine.
        <return_value> can be specified.
        The return value is retrieved by the calling source by using POP.

Example
        Calling source:
        CALL:sub
        POP:rc // Return value of 123 retrieved into variable rc.
        ... // Mandatory if calling a subroutine that has a return value.

        Subroutine side:
        :sub
                ...
        RETURN:123

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

Name
        RET - Return from subroutine (context value switch version)

Format
        RET:<context>

Arguments
        <context> Context value

Description
        Returns from subroutine.
        After returning, the context value is set to <context>.
        If the <context> value is 0, restores the context value when the subroutine was called.

Example
        Calling source:
        CALL:sub
        CASE:1:PRINT:"case 1..."
        CASE:2:PRINT:"case 2..."
        CASE:3:PRINT:"case 3..."
        ...

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

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

Name
        ONCALL - Register/cancel interrupt processing routine

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

        ONCALL:<-n>

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

        <label>             Interrupt processing routing label

        <resume_type> Return format
        <resume_label> Jump destination label after return

        <-n> Number of routines to be registered/deleted.

Description
        Register the interrupt routine <label> so that it is CALLed when the condition of <v1> <op> <v2> is met.
        Conditional specification methods are the same as IF.

        The return from the interrupt routine is carried out as follows:
        <resume_type>
        0  Return to statement that generated the interrupt.
        1  After returning to the statement that generated the interrupt, Go to <resume_label>.
        2  Return to location of ONCALL statement
        3  After returning to the location of the ONCALL statement, Go to <resume_label>.
        4  Return to beginning of program (entire stack is cleared).
        5  After returning to beginning of program, Go to <resume_label>.

        In 2 - 5, above, All ONCALL registrations after the corresponding ONCALL are deleted.
        In the case of 3 and 5, however, ONCALL commands registered at the same level as the return position are preserved.

        Conditional evaluation is conducted for each statement (line of R-CODE).

        Nested interrupts are prohibited (ignored).

        ONCALL is affected by the subroutine's nesting.
        An ONCALL registered in a subroutine becomes invalid when execution leaves that subroutine.


        If <-n> is specified, cancels the last n ONCALLs that have been registered.
        <-n> must be a negative number

Example
        ONCALL:RFLeg_ON:=:1:9000

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

Name
        RESUME - Return from interrupt routine

Format
        RESUME

Arguments
        None

Description
        Returns from interrupt routine.
        Equivalent to a RETURN for a CALL.
        RETURN may not be used to return from an interrupt routine.
        The return position depends on the <resume_type> of the ONCALL.

Example
        RESUME

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

Name
        GLOBAL - Global variable declaration

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

Arguments
        <var>         Variable name
        <init_value>  Initial value

Description
        Provides global variable <var>.
        If <init_value> is specified, the variable is initialized to this value.

        If a variable name not declared as either a GLOBAL or LOCAL variable is used,
        R-CODE system will automatically generate a global variable with that name.

Example
        GLOBAL:x:0

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

Name
        LOCAL - Local variable declaration

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

Arguments
        <var>                Variable name
        <init_value>         Initial value

Description
        Provides local variable <var>.
        If <init_value> is specified, the variable is initialized to this value.

        Local variables are prepared on the stack.
        The space for a local variable is freed when execution leaves its subroutine or scope.

Example
        LOCAL:y:0

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

Name
        LET - Variable assignment
Format
        LET:<var>:<value>

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

Description
        Assigns value to the variable.
        Special functions like SET do not function.

Example
        LET:x:1

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

Name
        SET - Variable assignment

Format
        SET:<var>:<value>

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

Description
        Assigns value to the variable.
        Special functions work with some variables.

        Power          Sets power on and off.
                        ** 2001/03/09 ***
                        If "SET:Power:1" is used while AIBO has gone limp after detecting a pinch,
                         the gain returns. 
                        In order to ensure safety, the Power variable is no longer used to turn the
                         power on and off.
                        Since the variable itself remains, there is no need to change your
                        programs.

        Head_ON          It is necessary to use SET to return these values to 0 after they
        Head_OFF         have been set by sensors, since they will stay that way otherwise.
        Head_Hit        
        Head_Pat        
        Head_Hit        
        Head_LONG       
        Back_ON         
        Back_OFF        
        Back_LONG       
        Jaw_ON          
        Jaw_OFF         
        Jaw_LONG        
        RFLeg_ON        
        RFLeg_OFF       
        LFLeg_ON        
        LFLeg_OFF       
        RRLeg_ON        
        RRLeg_OFF       
        LRLeg_ON        
        LRLeg_OFF       

Example
        SET:Power:1

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

Name
        GET - See variable values

Format
        GET:<var>

Arguments
        <var>                Variable name

Description
        Displays the value of variable <var> on the console.
        For debugging purpose.

Example
        GET:x

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

Name
        CLR - Clear sensor variable

Format
        CLR:SENSORS

Arguments
        None

Description
        Sets to 0 the value of those sensor variables with a format that stores the last value.

Example
        CLR:SENSORS

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

Name
        VSAVE - Save variable value

Format
        VSAVE:<var>

Arguments
        <var>                Variable name

Description
        Saves a variable value in a file on the Memory Stick.
        Stored in the file:

        /OPEN-R/APP/PC/AMS/<variable name>.SAV

        CAUTION!
        The file system limits the length of variable names that can be
        saved to a maximum of 8 characters.

Example
        VSAVE:x

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

Name
        VLOAD - Load variable value

Format
        VLOAD:<var>

Arguments
        <var>                Variable name

Description
        Reads a variable value from a file on the Memory Stick.
        Read from the file:

        /OPEN-R/APP/PC/AMS/<variable name>.SAV

        CAUTION!
        The file system limits the length of variable names that can be
        saved to a maximum of 8 characters.

Example
        VLOAD:x

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

Name
VDUMP                Display variable value

Format
        VDUMP:<var>

Arguments
        <var>                Variable name

Description
        Outputs variable value to the console in the following format:

            <variable name> = <variable value>

        This function is used for debugging when connected via WLAN.

Example
        VDUMP:x

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




        [ R-CODE Operator Quick Reference ]



  Operators

        Perform arithmetic operations, storing results in <var>.

        <var>                Variable name
        <value>              Value (variable name or 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 AND
        IOR:<var>:<value>        <var> <- <var> | <value> Bitwise OR
        XOR:<var>:<value>        <var> <- <var> ^ <value> Bitwise Exclusive OR
        NOT:<var>:<value>        <var> <- ~ <value> Bitwise Logical negation

        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 Negation

        RND:<var>:<from>:<to>        <var> <- Random Number in Range <from> - <to>

        The random number seed is specified by SET:Seed:<seed>.

        In addition to the above operations, are provided the stack operations listed below.
        POPs operand off stack, and PUSHes back the result.

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

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

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

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

        RND:<from>:<to>    <push> <- Random number in range <from> - <to>.
        RND:<to>           <push> <- Random number in range of 0 - <to>.

        Note:
        Elements are POPed from the stack in the order of <pop1> and <pop2>.
          PUSH:x
          PUSH:y
          SUB
          POP:z
        ...In this case, the value for z becomes x - y (not y - x).

  Stack

        PUSH:<var>      Variable value or constant is PUSHed onto the stack.

        POP[:<var>]     Pop up a value from the stack into a variable.
                        If <var> is not specified, the retrieved value is discarded.

        DUP               Copy the stack's top element, and PUSH it onto the stack.

        JT:<label>        POP the stack, and if the value is true, jump to <label>

        JF:<label>        POP the stack, and if the value is false, jump to <label>


        Note: Stack operations cannot cross subroutine or scope boundaries.





        [ List of R-CODE System Variables ]


   Note: System variables reserved by R-CODE are model-dependent.


   [Common to All Models]

        AiboId           AIBO ID (0-255)
                          0 when not connected via WLAN
                          When connected via WLAN, least significant byte of IP address
        AiboType         Model
                          210  ERS-210
                          220  ERS-220
                          310  ERS-310

        Year       Year (2000 or later)
        Month      Month (1-12)
        Day        Date (1-31)
        Hour       Hour (0-23)
        Min        Minute (0-59)
        Sec        Second (0-59)    *resolution 2 seconds
        Dow        Day of week (Sun(0), Mon(1), ..., Sat(6))

        Seed       Random number seed (default is 1)

        Power      Power (0/1):
                      0 OFF
                      1 ON
                      Has no meaning for versions 1.1 and later.
                      For details, see the description for the SET command.

        Status     Status:
                      0 Normal startup
                      1 Recovery
                      If AIBO recovers from falling, the program is started again from the beginning.
                      At this time, the value is set to 1.

        Context    Context value

        Wait       Number of actions being waited for completion

        Clock      Clock (incremented by 1 every 32 ms)


        Brightness       Ambient brightness (0-255)

        Pink_Ball        Pink ball (0/1)                                *
        Pink_Ball_H      Pink ball horizontal angle [degrees]
        Pink_Ball_V      Pink ball vertical angle [degrees]
        Pink_Ball_D      Distance to pink ball [mm]
                      The origin point of the position of Pink ball
                      is a position of Image sensor.

        AU_Voice        Voice recognition (0/1)                 *
        AU_Voice_ID     Voice ID (1-53)                         see [Voice ID List]
        AU_AiboSound    AiboSound detection (0/1)               *
        AU_AiboSound_ID AiboSound ID (1-35)                     see [AiboSound ID List]
        AU_AiboTone     AiboTone detection (0/1)                *
        AU_AiboTone_ID  AiboTone ID (1-68)                      see [AiboTone ID List]

        Temp_Hi         Temperature at which operation is suppressed (0/1) (for safety, a forced shutdown will be executed in 20 seconds).

         * These values will not automatically return to 0 once they are set by sensors.
            You have to use SET to return them to 0.




   [ERS-210]

        Head_Tilt       Head: vertical (up-down) angle [degrees]
        Head_Pan        Head: horizontal (left-right) angle [degrees]
        Head_Roll       Head: roll angle [degrees]
        Mouth           Mouth: Amount open [degrees]
        LFLeg_1         Left-front leg J1 (hip joint): angle in front/back direction [degrees]
        LFLeg_2         Left-front leg J1 (hip joint): angle in left/right direction [degrees]
        LFLeg_3         Left-front leg J2 (knee joint): angle in front/back direction [degrees]
        LRLeg_1         Left-hind leg J1 (hip joint): angle in front/back direction [degrees]
        LRLeg_2         Left-hind leg J1 (hip joint): angle in left/right direction [degrees]
        LRLeg_3         Left-hind leg J2 (knee joint): angle in front/back direction [degrees]
        RFLeg_1         Right-front leg J1 (hip joint): angle in front/back direction [degrees]
        RFLeg_2         Right-front leg J1 (hip joint): angle in left/right direction [degrees]
        RFLeg_3         Right-front leg J2 (knee joint): angle in front/back direction [degrees]
        RRLeg_1         Right-hind leg J1 (hip joint): angle in front/back direction [degrees]
        RRLeg_2         Right-hind leg J1 (hip joint): angle in left/right direction [degrees]
        RRLeg_3         Right-hind leg J2 (knee joint): angle in front/back direction [degrees]
        Tail_Pan        Tail: horizontal (left/right) angle [degrees]
        Tail_Tilt       Tail: Vertical (up/down) angle [degrees]

        Batt_Rest       Battery charge remainder [%]
        Batt_Temp       Battery temperature [C]
        Body_Temp       Body temperature [C]

        Distance        Distance to obstacle [mm]

        Head_Pat        Head sensor stroked back and forth twice (0/1) *
        Head_Hit        Head sensor touched briefly and forcefully (0/1) *
        Head_ON         Head sensor pressed (0/1)                  *
        Head_OFF        Amount of time head sensor pressed [ms]
        Head_LONG       Head sensor pressed for 3 seconds or more (0/1)        *

        Back_ON         Back sensor was pressed (0/1)                  *
        Back_OFF        Amount of time back sensor was pressed [ms]
        Back_LONG       Back sensor was pressed for 3 seconds or more (0/1) *

        Jaw_ON          Chin sensor was pressed (0/1)                  *
        Jaw_OFF         Amount of time chin sensor was pressed [ms]
        Jaw_LONG        Chin sensor was pressed for 3 seconds or more (0/1) *

        RFLeg_ON        Right front paw sensor was pressed (0/1)        *
        RFLeg_OFF       Amount of time right front paw sensor was pressed [ms]
        LFLeg_ON        Left front paw sensor was pressed (0/1)                *
        LFLeg_OFF       Amount of time left front paw sensor was pressed [ms]
        RRLeg_ON        Right hind paw sensor was pressed (0/1)                *
        RRLeg_OFF       Amount of time right hind paw sensor was pressed [ms]
        LRLeg_ON        Left hind paw sensor was pressed (0/1)                *
        LRLeg_OFF       Amount of time left hind paw sensor was pressed [ms]

         * These values will not automatically return to 0 once they are set by sensors.
            You have to use SET to return them to 0.




   [ERS-310]

        Head_Tilt       Head: vertical (up-down) angle 1 [degrees]
        Head_Tilt_2     Head: vertical (up-down) angle 2 [degrees]
        Head_Pan        Head: horizontal (left-right) angle [degrees]
        LFLeg_1         Left-front leg J1 (hip joint): angle in front/back direction [degrees]
        LFLeg_2         Left-front leg J1 (hip joint): angle in left/right direction [degrees]
        LFLeg_3         Left-front leg J2 (knee joint): angle in front/back direction [degrees]
        LRLeg_1         Left-hind leg J1 (hip joint): angle in front/back direction [degrees]
        LRLeg_2         Left-hind leg J1 (hip joint): angle in left/right direction [degrees]
        LRLeg_3         Left-hind leg J2 (knee joint): angle in front/back direction [degrees]
        RFLeg_1         Right-front leg J1 (hip joint): angle in front/back direction [degrees]
        RFLeg_2         Right-front leg J1 (hip joint): angle in left/right direction [degrees]
        RFLeg_3         Right-front leg J2 (knee joint): angle in front/back direction [degrees]
        RRLeg_1         Right-hind leg J1 (hip joint): angle in front/back direction [degrees]
        RRLeg_2         Right-hind leg J1 (hip joint): angle in left/right direction [degrees]
        RRLeg_3         Right-hind leg J2 (knee joint): angle in front/back direction [degrees]

        Batt_Rest       Battery charge remainder [%]
        Batt_Temp       Battery temperature [C]
        Body_Temp       Body temperature [C]

        Distance        Distance to obstacle [mm]

        Head_Pat        Head pressed so that face points downward        *
        Head_Hit        Head pressed so that face points upward          *
        Head_ON         Head pressed (0/1)                               *
        Head_OFF        Amount of time head pressed [ms]
        Head_LONG       Head pressed for 3 seconds or more (0/1)         *

        RFLeg_ON        Right front paw switch was pressed (0/1)         *
        RFLeg_OFF       Amount of time right front paw switch was pressed [ms]
        LFLeg_ON        Left front paw switch was pressed (0/1)                *
        LFLeg_OFF       Amount of time left front paw switch was pressed [ms]
        RRLeg_ON        Right hind paw switch was pressed (0/1)                *
        RRLeg_OFF       Amount of time right hind paw switch was pressed [ms]
        LRLeg_ON        Left hind paw switch was pressed (0/1)                 *
        LRLeg_OFF       Amount of time left hind paw switch was pressed [ms]

        Tail_Roll3      Tail rotated 3 times (in either direction) (0/1)  *
        Tail_RollR      Tail rotated clockwise (0/1)                      *
        Tail_RollL      Tail rotated counterclockwise (0/1)               *
        Tail_U_LONG     Tail pressed forward 3 seconds (0/1)              *
        Tail_D_LONG     Tail pressed backward 3 seconds (0/1)             *
        Tail_R_LONG     Tail pressed right 3 seconds (0/1)                *
        Tail_L_LONG     Tail pressed left 3 seconds (0/1)                 *
        Tail_U_ON       Tail pressed forward (0/1)                        *
        Tail_D_ON       Tail pressed backward (0/1)                       *
        Tail_R_ON       Tail pressed right (0/1)                          *
        Tail_L_ON       Tail pressed left (0/1)                           *

         * These values will not automatically return to 0 once they are set by sensors.
            You have to use SET to return them to 0.



   [ERS-220]

        Head_Tilt       Head: vertical (up-down) angle [degrees]
        Head_Pan        Head: horizontal (left-right) angle [degrees]
        Head_Roll       Head: roll angle [degrees]
        LFLeg_1         Left-front leg J1 (hip joint): angle in front/back direction [degrees]
        LFLeg_2         Left-front leg J1 (hip joint): angle in left/right direction [degrees]
        LFLeg_3         Left-front leg J2 (knee joint): angle in front/back direction [degrees]
        LRLeg_1         Left-hind leg J1 (hip joint): angle in front/back direction [degrees]
        LRLeg_2         Left-hind leg J1 (hip joint): angle in left/right direction [degrees]
        LRLeg_3         Left-hind leg J2 (knee joint): angle in front/back direction [degrees]
        RFLeg_1         Right-front leg J1 (hip joint): angle in front/back direction [degrees]
        RFLeg_2         Right-front leg J1 (hip joint): angle in left/right direction [degrees]
        RFLeg_3         Right-front leg J2 (knee joint): angle in front/back direction [degrees]
        RRLeg_1         Right-hind leg J1 (hip joint): angle in front/back direction [degrees]
        RRLeg_2         Right-hind leg J1 (hip joint): angle in left/right direction [degrees]
        RRLeg_3         Right-hind leg J2 (knee joint): angle in front/back direction [degrees]

        Batt_Rest       Battery charge remainder [%]
        Batt_Temp       Battery temperature [C]
        Body_Temp       Body temperature [C]

        Distance        Distance to obstacle [mm]

        Head_Pat        Head sensor was pressed backward (0/1) *
        Head_Hit        Head sensor was pressed forward (0/1)  *
        Head_ON         Head sensor was pressed (0/1)          *
        Head_OFF        Length of time head sensor was pressed [ms]
        Head_LONG       Head sensor was pressed for 3 seconds or longer (0/1) *

        Back_ON         Back sensor pressed (0/1)              *
        Back_OFF        Length of time back sensor was pressed [ms]
        Back_LONG       Back sensor was pressed for 3 seconds or longer (0/1) *

        Jaw_ON          Face sensor pressed (0/1)              *
        Jaw_OFF         Length of time face sensor was pressed [ms]
        Jaw_LONG        Face sensor was pressed for 3 seconds or longer (0/1) *

        RFLeg_ON        Paw sensor on right-front leg was pressed (0/1)  *
        RFLeg_OFF       Length of time paw sensor on right-front leg was pressed [ms]
        LFLeg_ON        Paw sensor on left-front leg was pressed (0/1)   *
        LFLeg_OFF       Length of time paw sensor on left-front leg was pressed [ms]
        RRLeg_ON        Paw sensor on right-hind leg was pressed (0/1)   *
        RRLeg_OFF       Length of time paw sensor on right-hind leg was pressed [ms]
        LRLeg_ON        Paw sensor on left-hind leg was pressed (0/1)    *
        LRLeg_OFF       Length of time paw sensor on left-hind leg was pressed [ms]

        RTail_ON        Press right tail touch sensor (0/1)    *
        RTail_OFF       Length of time right tail touch sensor is pressed [ms]
        RTail_LONG      Press right tail touch sensor for 3 seconds or longer (0/1)  *
        CTail_ON        Press center tail touch sensor (0/1)   *
        CTail_OFF       Length of time center tail touch sensor is pressed [ms]
        CTail_LONG      Press center tail touch sensor for 3 seconds or longer (0/1) *
        LTail_ON        Press left tail touch sensor (0/1)     *
        LTail_OFF       Length of time left tail touch sensor is pressed [ms]
        LTail_LONG      Press left tail touch sensor for 3 seconds or longer (0/1)   *

         * These values will not automatically return to 0 once they are set by sensors.
            You have to use SET to return them to 0.



   [Voice ID List]

        ID                Word
        1                AIBO
        2                What's your name?
        3                Say hello
        4                Shake paw
        5                Morning
        6                Hello
        7                Good night
        8                See you
        9                How are you?
        10               Hey AIBO
        11               Thanks
        12               Sorry
        13               Cheer up
        14               Banzai
        15               That's right
        16               That's wrong
        17               Good AIBO
        18               Don't do that
        19               Let's play!
        20               Sing a song
        21               Dance
        22               Show time
        23               Pose for me
        24               Clown around
        25               Show off
        26               Say message
        27               Let's be secret
        28               Open sesame
        29               Happy day
        30               Stand up
        31               Lie down
        32               Sit down
        33               Turn right
        34               Turn left
        35               Go forward
        36               Go backward
        37               Go ahead
        38               Stop
        39               Faster
        40               Slow down
        41               Pink ball
        42               Right leg kick
        43               Right leg touch
        44               Left leg kick
        45               Left leg touch
        46               Ready set go
        47               You won
        48               You lost
        49               Action one
        50               Action two
        51               Action three
        52               Action four
        53               Action five



   [AiboSound ID List]
        ID       Description                                             MIDI filename *
        1        Start communicating with other AIBO                     AS01_Start_AC.mid
        2        Starts media link mode.(1)                              AS02_Start_ML1.mid
        3        Starts media link mode.(2)                              AS03_Start_ML2.mid
        4        Starts media link mode.(3)                              AS04_Start_ML3.mid
        5        Ends media link mode, and returns to autonomous mode.   AS05_End_ML.mid
        6        Raises a front paw to say greeting.                     AS06_Hello.mid
        7        Waves a front paw to say goodbye.                       AS07_Bye.mid
        8        Lies on its stomach and pretends to sleep.              AS08_Sleep.mid
        9        Gives a short nod.                                      AS09_Nod_Short.mid
        10       Gives a long nod.                                       AS10_Nod_Long.mid
        11       Shows great expectation.                                AS11_Expect.mid
        12       Responds positively.                                    AS12_Yes.mid
        13       Responds negatively.                                    AS13_No.mid
        14       Responds questioningly.                                 AS14_Question.mid
        15       Pose of joy.                                            AS15_Joy.mid
        16       Pose of great joy.                                      AS16_Happy.mid
        17       Pose of reluctance.                                     AS17_Disgust.mid
        18       Pose of surprise.                                       AS18_Surprise.mid
        19       Pose of sadness.                                        AS19_Sad.mid
        20       Pose of relieved look.                                  AS20_Relief.mid
        21       Requests and desires.                                   AS21_Appeal.mid
        22       Performs various characteristic actions.                AS22_Action.mid
        23       Dances.                                                 AS23_Dance.mid
        24       Sings.(1)                                               AS24_Song1.mid
        25       Sings.(2)                                               AS25_Song2.mid
        26       Performs favorite dance.                                AS26_Fav_Dance.mid
        27       Pose of fear.                                           AS27_Fear.mid
        28       Bows.                                                   AS28_Greet.mid
        29       Poses for photo opportunity.                            AS29_Pose.mid
        30       Riases both front paws.                                 AS30_Cheer.mid
        31       Pose of caution.                                        AS31_Look.mid
        32       Pose of shyness.                                        AS32_Abash.mid
        33       Acts charmingly.                                        AS33_Charm.mid
        34       Tells you its characteristic type.                      AS34_Type_Check.mid
        35       Notices incoming call.                                  AS35_Call.mid

        * MIDI files are provided under Sample/AiboSound folder of AiboMasterStudio.



   [AiboTone ID List]

        ID               Tones (3tones)              MIDI filename *
        1                C5  D5  E5                  AT01.mid
        2                C5  E5  D5                  AT02.mid
        3                E5  C5  D5                  AT03.mid
        4                E5  D5  C5                  AT04.mid
        5                G5  C5  D5                  AT05.mid
        6                G5  D5  C5                  AT06.mid
        7                C5  G5  D5                  AT07.mid
        8                C5  D5  G5                  AT08.mid
        9                D5  E5  C5                  AT09.mid
        10               D5  C5  E5                  AT10.mid
        11               C5  Eb5 G5                  AT11.mid
        12               C5  G5  Eb5                 AT12.mid
        13               G5  Eb5 C5                  AT13.mid
        14               C5  E5  F5                  AT14.mid
        15               C5  F5  E5                  AT15.mid
        16               F5  C5  E5                  AT16.mid
        17               F5  E5  C5                  AT17.mid
        18               C5  F5  G5                  AT18.mid
        19               C5  G5  F5                  AT19.mid
        20               G5  C5  F5                  AT20.mid
        21               G5  F5  C5                  AT21.mid
        22               F5  C5  G5                  AT22.mid
        23               C5  D5  F5                  AT23.mid
        24               Eb5 C5  F5                  AT24.mid
        25               C5  F5  D5                  AT25.mid
        26               D5  F5  C5                  AT26.mid
        27               D5  C5  F5                  AT27.mid
        28               F5  D5  C5                  AT28.mid
        29               F5  C5  D5                  AT29.mid
        30               Eb5 F5  C5                  AT30.mid
        31               C5  Eb5 F5                  AT31.mid
        32               C5  F5  Eb5                 AT32.mid
        33               F5  C5  Eb5                 AT33.mid
        34               F5  Eb5 C5                  AT34.mid
        35               C6  D6  E6                  AT35.mid
        36               C6  E6  D6                  AT36.mid
        37               E6  C6  D6                  AT37.mid
        38               E6  D6  E6                  AT38.mid
        39               G6  C6  D6                  AT39.mid
        40               G6  D6  C6                  AT40.mid
        41               C6  G6  D6                  AT41.mid
        42               C6  D6  G6                  AT42.mid
        43               D6  E6  C6                  AT43.mid
        44               D6  C6  E6                  AT44.mid
        45               C6  Eb6 G6                  AT45.mid
        46               C6  G6  Eb6                 AT46.mid
        47               G6  Eb6 C6                  AT47.mid
        48               C6  E6  F6                  AT48.mid
        49               C6  F6  E6                  AT49.mid
        50               F6  C6  E6                  AT50.mid
        51               F6  E6  C6                  AT51.mid
        52               C6  F6  G6                  AT52.mid
        53               C6  G6  F6                  AT53.mid
        54               G6  C6  F6                  AT54.mid
        55               G6  F6  C6                  AT55.mid
        56               F6  C6  G6                  AT56.mid
        57               C6  D6  F6                  AT57.mid
        58               Eb6 C6  F6                  AT58.mid
        59               C6  F6  D6                  AT59.mid
        60               D6  F6  C6                  AT60.mid
        61               D6  C6  F6                  AT61.mid
        62               F6  D6  C6                  AT62.mid
        63               F6  C6  D6                  AT63.mid
        64               Eb6 F6  C6                  AT64.mid
        65               C6  Eb6 F6                  AT65.mid
        66               C6  F6  Eb6                 AT66.mid
        67               F6  C6  Eb6                 AT67.mid
        68               F6  Eb6 C6                  AT68.mid

        * MIDI files are provided under Sample/AiboTone folder of AiboMasterStudio.

 [WirelessLAN communication]

********************************************************************

One can send the program written in R-CODE to AIBO via wireless LAN 
transmission.
In order to send program written in R-CODE ver. 1.2 and after via 
wireless connection with AIBO Master Studio, AIBO Master Studio is 
programmed to ask for ID and password authentication.

However, if you delete 
      /OPEN-R/SYSTEM/CONF/WLAN/OWNER.TXT 
and create
      /OPEN-R/APP/PC/AMS/NOAUTH.CFG
instead, it will not ask for ID and password.
The content for NOAUTH.CFG can be anything (size=0 is recommended)

Please note that if no authentication is done or network security is 
not properly set, other PCs may have access to the same AIBO.

Specification for the connection is as follows:

     Connection port : 21002 tcp
     Protocol : no flow control
     Code     : 8 bit ASCII

Sample (using telnet)
------------------------------------------------------------------
C:\>telnet.10.0.1.1 21002                       <== DOS prompt

============================================
R-CODE ver1.2 (2001/11/22)                      <== Such a header will 
============================================      be displayed if it 
string_buf   1 *  256K =  256K (used  0.1%)       succeeds in connection.
dictionary   8 *   32K =  256K (used  0.7%)
stack        4 *   32K =  128K (used  0.3%)
statement   24 *   32K =  768K (used  0.0%)
on_call     12 *   64  =  768  (used  0.0%)
============================================
free mem.   6998912
============================================
<READY>                                         <== You can input from here.
PLAY:ACTION:STAND                               <== You can executed the command "rise" directly.
EDIT                                            <== Your program can be sent from EDIT to END.
  FOR:i:1:10                                    <== This becomes the program which repeats the motion
    PLAY:ACTION:SIT                                 "sit and stand" 10 times.
    WAIT
    PLAY:ACTION:STAND
    WAIT
  NEXT
END
RUN                                             <== Your program runs.
c
@DISS                                           <== @DISS cuts the Connection.

C:\>

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

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