tutorial
reference
bugs
CVS
BBS
Downloads

Downloads

Prerequisite Check

Development Host Platform:

Linux/BSD     Mac OS X     Windows

Target Platform(s):

Platform “local” — supports execution directly on the host platform
Cygwin (a linux compatibility layer for Windows) has several bugs/flaws, which prevent “local” Tekkotsu execution and make it unsuitable as a development environment. It is recommended to run full Linux, either under a virtual machine within Windows, or via dual-boot. (in either case, select “Linux” as the host above)
Platform “Aperios” — supports execution onboard the Aibo series of robots

Target Robot Model(s):

Regis prototype
Qwerk-based robots (e.g. Qwerkbot+)
Lynxmotion 6-DOF SES arm
iRobot Create (preliminary support)
Note: The Create does not include sufficient computational power, so you will need a controller board, such as a Qwerk, gumstix, Geode, Via, etc.
Robotis Bioloid/Dynamixel-based kits (preliminary support)
Note: The CM-5 controller that comes in Bioloid kits cannot run Tekkotsu onboard, so you will need a separate controller board, such as a Qwerk, gumstix, Geode, Via, etc. A USB-to-TTL converter (HUV Robotics or USB2Dynamixel) is also needed.
ERS-210, ERS-220, or ERS-7 Aibo
Note: without platform-local, only “onboard” Aibo computation will be supported.
Note: without platform-aperios (see previous section), only simulated Aibo computation will be supported. (off-board computation may be supported by precompiled memory stick at a later time.)

Desired Components:

Graphical user interface — tools to control behavior selection and interaction
TeRK — provides offboard control of Qwerk-based robots
Note: TeRK is currently required to control Qwerk hardware. However, you can still compile and simulate Qwerk-based robots on the local host.
Camera (usb or firewire)

Anticipated Prerequisites for Tekkotsu Development:

• Cygwin - provides a unix-style compatibility layer within Windows. Installation guide...
•Xcode - provides compiler tools on Mac OS X platforms. Be sure you have the most recent version from Apple. (free download!). After you've installed, follow this guide to configure for Tekktosu.
cancelOPEN-R SDK - provides programming interface for Sony's Aperios platform. You need to install it to work with Aibo-series robots, but you won't interact with it directly (Tekkotsu abstracts that away for you!) Installation guide...
•C compiler - you may need to select the C compiler (e.g. gcc) in your package manager to build OPEN-R
cancelICE (Internet Communication Engine) 3.1.1 - provides a serialized communication protocol, used by the TeRK component.
If you are using an Intel-based Mac, you will need to compile the library from source. We recommend using MacPorts or Fink to acquire ICE's dependencies (“expat” and Berkeley's “db4”).
If you are using Xcode, be sure to update your Source Trees by adding ICE_ROOT = /usr/local/Ice (or wherever you installed it), and HAVE_ICE = -DHAVE_ICE, as shown on the Xcode setup page.
•Java 5 - all of our GUI tools use Java for maximum portability. You can get the most recent version from Apple. You can get the most recent version from java.com. (or your package manager)
•libpng and libjpeg - provides Tekkotsu with the ability to compress and exchange image data. You can obtain these libraries through package-based installers, MacPorts, or Fink. (With the latter two, be sure to set CXXFLAGS and LDFLAGS environment variables appropriately)
•Library dependencies - make sure your package manager has the following items selected:
  • C++ compiler (gcc and g++)
  • libpng-dev (aka libpng12-dev)
  • libjpeg-dev (aka libjpeg62-dev)
  • libxml2-dev
  • readline-dev or editline-dev
•QuickTime - provides interface to video capture devices. (should be pre-installed, just make sure it's up to date.) If using a third-party webcam (i.e. not just Apple's own iSight), you may also need drivers from macam.
•video4linux - provides interface to video capture devices. (should be pre-installed with your distribution as it is integrated with the kernel)

Acquiring Tekkotsu

Installation and configuration instructions follow in a later section.

  • Option 1: Latest Release

    ->Tekkotsu 4.0 Release ( 7.2MB): includes source for framework and associated tools.

    If you are upgrading from a previous release, let cvs do the work for you:

    cvs update -dP -r tekkotsu-4_0

    Be sure to run in both the Tekkotsu framework directory and any external projects so they are kept in sync. See our CVS Usage page for more information.

  • Option 2: Current “Stable” Point

    We generally make releases on a per-semester basis, but that doesn't mean you have to wait for new features and bug fixes. Use CVS to grab the code at what we feel is a reasonably stable state:

    cvs -d :pserver:anonymous@cvs.tekkotsu.org:/cvs checkout -r STABLE -P Tekkotsu

    This will create a new directory named “Tekkotsu”, which you can rename and relocate. See the CVS Usage page for more information.

  • Option 3: Bleeding Edge Source

    This will get the most recent code from CVS. Recommended for testing before sending us a patch to make sure there won't be any conflicts with any modifications we've made.

    cvs -d :pserver:anonymous@cvs.tekkotsu.org:/cvs checkout -P Tekkotsu

    This will create a new directory named “Tekkotsu”, which you can rename and relocate. See the CVS Usage page for more information.

Add-on Packages

  • Precompiled GUI tools

    ( 495kB) - to be used with the 4.0 release listed above.

    The tools are also included in the full Tekkotsu downloads above. This package is a convenience for times when you want to run just the controls on a machine without the full development environment. Those who have CVS checkouts shouldn't use this — run from the tools/mon directory to ensure version synchronization.

  • Storyboard Viewer

    (by Akkarit Sangpetch) - Allows you to graphically view State Machine status, and record execution traces with rich media logging. Written using the eclipse development framework, requires Java.

    Select your platform (executable binaries):

  • Reference Documentation

    - downloadable package for offline viewing:

    • Reference Documentation (19.0MB )
      Also available online -- see "reference" link in the upper right section of the page header.
    • Quick Reference sheets (PDF): ERS-7, ERS-210, ERS-220
      Lists commonly used build settings and targets, controller ports and commands, model specific parameters, and built-in event generators.

    Also available online — see "reference" link in the upper right section of the page header.

Tekkotsu Source Installation:

  1. Install any applicable prerequisites, as listed above.
  2. Download the Tekkotsu framework.
    • This will be compiled into static and shared libraries for each combination of platform and model.  You will use a separate project directory for your local development.
    • Untar the Tekkotsu source package and move it to /usr/local/Tekkotsu.
      You could install the framework at a different location, but if you do, be sure to set the TEKKOTSU_ROOT environment variable, as described in Configuration.
    • The build scripts currently break if the path to the Tekkotsu root directory contains a space.  If your installation path includes a space, you may be able to set TEKKOTSU_ROOT as a relative path from your project to the installation directory.
  3. Once decompressed, construct a fresh project by copying the <Tekkotsu>/project directory to a location of your choosing.
    • This will be where you do your local development, and will help you differentiate your files from the framework files.
    • You can have multiple projects, and multiple behaviors per project.  However, only one project can be stored on a memory stick at any given time. (The Aibo "boots" into the project from the memory stick, so only one project can be available at a time.)

Tekkotsu Configuration:

For customized instructions, select your target model family(s) below:
Regis Qwerk Lynxmotion arm
Create Bioloid/Dynamixel Aibo
  • Each project should contain a file, Environment.conf.  This file is included and parsed by various libraries and tools in the framework.
    There are several particularly significant variables near the top of this Environment.conf file:
    • TEKKOTSU_ROOT (defaults to /usr/local/Tekkotsu)
    • MEMSTICK_ROOT (defaults to /mnt/memstick on Linux, /cygdrive/e on Cygwin/Windows, and attempts to auto-detect most recent mount on Mac OS X.)
    • OPENRSDK_ROOT (defaults to /usr/local/OPEN_R_SDK)
    • TEKKOTSU_TARGET_MODEL (defaults to TGT_ERS7, see robot listing for other valid values)
    • TEKKOTSU_TARGET_PLATFORM (defaults to PLATFORM_LOCAL, but can be set to PLATFORM_APERIOS to cross-compile for onboard Aibo execution.) (defaults to PLATFORM_APERIOS for Aibo models, otherwise defaults to PLATFORM_LOCAL for local execution.)
  • If these do not correspond to your configuration, you can change them a variety of ways:
    • Temporary basis: You can assign values when invoking make (below) by passing arguments of the form VAR=VALUE. This is handy if you are often switching back and forth between two settings, such as if you testing changes on different robot models. Passing a value on the command line overrides values set by either of the two methods listed below.
    • Set an environment variable: This is the recommended method if you are working in a team on shared code, where each team member may need different settings. You could set it for a single terminal session, or add it to your login script to keep it set to a particular value. An environment variable will override the default value listed in Environment.conf.
    • Change the Environment.conf value: This will allow the change to be specific to a particular project and sets the default value to be used if neither of the other methods have been applied.
  • There are other variables which may be of interest, listed in either Environment.conf or near the top of the Makefile, each with inline documentation.
  • To access the Aibo using wireless ethernet, you will need to customize the configuration info for your network, found in:
    <project>/ms/open-r/system/conf/wlandflt.txt
    • See the Sony SDK Documentation if you have trouble with the wlandflt.txt file.  However, it's fairly straightforward if you are familiar with network configuration.
    • If your network uses DHCP to dynamically assign internet addresses, you will either need to configure your wireless access point (WAP) to assign a known IP address based on the AIBO's MAC address, or else read the FAQ entry on determining the AIBO's IP address at runtime.

Tekkotsu Compilation:

For customized instructions, select your target model family(s) below:
Regis Qwerk Lynxmotion arm
Create Bioloid/Dynamixel Aibo
  • These instructions are regarding command line usage. If you intend to use Xcode as your development environment, go to the Xcode setup page.
  • Is your Tekkotsu framework directory (i.e. /usr/local/Tekkotsu) is owned by root?
    Yes No
    1. cd to the framework directory.
    2. For each of the robot models you intend to target, run:
      sudo make TEKKOTSU_TARGET_MODEL=TGT_FOO
      (replacing “FOO” with your target's name, as listed on the Robots page.)
      This will build the static and shared libtekkotsu for your projects to link against later. This is a one-time thing, unless you modify the framework itself.
    3. You may wish to set TEKKOTSU_ALWAYS_BUILD to an empty string in your projects' Environment.conf so they will not check the framework directory for changes each build. (However, if you do so, be careful that you don't modify a file in the framework and forget to recompile it!)
    As long as TEKKOTSU_ALWAYS_BUILD is enabled in Environment.conf, the framework directory will be updated for the current platform and model each time a project is built. Of course, this requires write permission for the developer into the framework directory...
  • Where do you want to run the code?
    Offboard/Desktop execution
    (None of your selected models/platforms
    support local execution)
    Onboard/Robot execution
    (None of your selected models/platforms
    support onboard execution)
    To build an executable for the local host...
    1. cd to your project directory.
    2. Type:
      make tekkotsu
      This will produce an executable named tekkotsu-FOO, where FOO is the name of your target model.
    To cross-compile for onboard execution...
    1. Put a blank memory stick in your drive.
    2. cd to your project directory.
    3. There are two ways have executables built and then automatically copied to the memory stick.  Either of these methods will (re)build any necessary object files before copying them.
      • If you have rsync installed, type:
        make update
        This will copy both project and system files to your memory stick.
      • If you do not have rsync installed:
        # first time for blank memory stick, copy system files
        make newstick
        # subsequent builds, copy entire contents of 'ms' directory
        make install
    4. You can type make by itself to only recompile and not copy to the memory stick. (this uses current TEKKOTSU_TARGET_PLATFORM setting... this could recompile either the local 'tekkotsu' executable, or the Aperios executables.)
  • Don't worry if you see a few warnings during build - we enable many stringent warnings by default, and some warnings are false positives. Others are from bundled libraries that were developed in less rigorous environments.
  • If the make fails, check that you have installed all of the prerequisites for your environment, and have set the appropriate values in step 1 of Configuration.
  • For reference, make targets applicable to your selected environment are:
    • make - builds and links executables (and for Aibo, copies binaries into ms directory, but not the memory stick)
    • make sim - intended for Aibos, overrides target platform to PLATFORM_LOCAL
    • make update - intended for Aibos, overrides target platform to PLATFORM_APERIOS, builds the code, then copies the files that have changed in the ms directory to the memory stick (uses rsync)
    • make install - intended for Aibos, overrides target platform to PLATFORM_APERIOS, builds the code, then copies the entire ms directory to the memory stick
    • make newstick - intended for Aibos, copies the system files to the memory stick.
    • make clean - deletes all object files, executable binaries, and other temporary files from the project, and if TEKKOTSU_ALWAYS_BUILD is set, Tekkotsu framework directory as well.
    • make cleanProj - deletes all object files, executable binaries, and other temporary files from the project directory
    • make cleanDeps - deletes only the header dependancy (.d) files from both framework and project, which may be necessary if an #include for a non-existent file was processed.  The .d files will be automatically regenerated, and object files will not necessarily need to be recompiled.
    • There are also FTP tools available in the tools directory which will transfer code over a wireless connection and then reboot the Aibo.

Basic Tekkotsu Usage: (Non-Aibo)

  1. Turn on your robot.
  2. If running Tekkotsu off-board, configure the Hardware Abstraction Layer to connect to the robot.
  3. The robot starts out in emergency stop (e-stop) mode.  In this mode the Controller is active, which allows you to turn behaviors on and off (if your robot has buttons and the Controller is configured to use them).
  4. From within the TekkotsuMon directory (either the precompiled package available above, or the tools/mon directory of the framework), type:
        ./ControllerGUI <IP address>
    If you are running offboard (on the local machine), use localhost as the address. Otherwise it will be the robot's own IP address.
    • If you don't know the IP address, for instance because you are using DHCP to dynamically assign an address, please see the FAQ entry for determining the AIBO's Internet address. This requires your robot to have enough LEDs to display numeric values.
  5. This will launch the Java VM and load the Controller GUI, bringing up the window shown here:
    • If the GUI does not connect, try using the ping command to test your network connection.
      ping <Robot IP address>
  6. Click the red “stop sign” in the lower left hand corner of the controller window to toggle the emergency stop. If your robot has buttons, some of these may be used to toggle the e-stop as well.
  7. See the TekkotsuMon Tutorial for more information on the available tools.

Basic Tekkotsu Usage: (Aibo)

  1. If you have an ERS-7, make sure the Wireless LAN switch on the underside is 'on'.  Otherwise the Aibo will not boot.
  2. Put the memory stick in the Aibo and turn it on.  The light below the power button should turn green and you should hear a few high-pitched ("happy") notes.
  3. The Aibo starts out in emergency stop (e-stop) mode.  In this mode the Controller is active, which allows you to turn behaviors on and off.
  4. Double-tap the "back" button to disable (or re-enable) the emergency stop.  The e-stop (just a high priority MotionCommand) will override lower priority behaviors and allows the joints to give under pressure to prevent damage.
  5. See the TekkotsuMon Tutorial for a list of available controls which can be selected, and how to navigate the menus.
  6. From within the TekkotsuMon directory (either the precompiled package available above, or the tools/mon directory of the framework), type:
      ./ControllerGUI <Aibo IP address>
  7. This will launch the Java VM and load the Controller GUI, bringing up the window shown here:
    • If the GUI does not connect, try using the ping command to test your network connection.
      ping <Aibo IP address>
  8. See the TekkotsuMon Tutorial for more information on the available tools.

Downloads
Last modified: 2008-03-20