1. Installing ODE 0.11
   1. Downlaod ode-0.11.1.zip. Save it to desktop and decompress.
   2. Copy the ode-0.11.1 folder to the top of the C drive shown as follows.

      • c:\ode-0.11.1 

   3. Start the Command Prompt.
      • Start → “Programs” → “Accessories” → “Command Prompt”
   4. Input commands as follows. These commands are complicate, so I recommend Cut and paste .

      •  cd c:\ode-0.11.1\build 

      •  premake4 --with-demos --cc=gcc --os=windows codeblocks 

        Note: in front of the “with-demos” and  ”cc=gcc”, there are two  - (minus). See the  image below.

      • The “codeblocks” folder should be created in the “build” folder, please check it.

        • C:\ode-0.11.1\build\codeblocks




2. Building ODE
   1. Start Code:: Blocks.
   2. Select the below file  from the menu bar “File (F)” → “Open (O)”,  or simply double-click the file.

      •  c:\ode-0.11.1\build\codeblocks\ode.workspace

   3. Important: Build target must be choosed as DebugDoubleLib (where the red circle in the picture below)
      • This makes debugging, double and a static library. The ODE project recommend the static library (LIB) instead of  the dynamics link library (DLL).
   4. Select “Building (B)” → “building the workspace (W)” . Workspace is similar to the solution in Visual C + +.
      • Executable files of demonstration programs are generate in

        C: \ode-0.11.1\lib\DebugDoubleLib

        
        

      • Double click the demo_buggy.exe,  and enjoy it.
      • That’s all.
3. How to build my sample programs in the ODE book.
   1. Down load my sample programs, roboSimu090614.zip,  from here.
   2. Copy the zip file in c: ¥ ode-0.11.1 folder, and extract it. The following folder should be created.
      • c:\ode-0.11.1\roboSimu
   3. Same as the ODE installation, you can use the premake. Run the command prompt and input the following commands.
      • cd c:\ode-0.11.1\roboSimu
      • premake –target cb-gcc
      • Note: There are two – (minus) in front of the “target”.

   4. Start the Code:: blocks

   5. Select “File (F)” → “Open (O)” from the menu bar, and the select following file

      • c:\ode-0.11.1\roboSimu\src\roboSimu.workspace

   6. Important: Set the build target as DebugLib.
      You built the library as DebugDoubleLib in ODE,  so DebugLib must be selected.
   7. Select “Building (B)” → “building the workspace (W)”. If you get an error, rebuild the ODE library.
   8. Run the sample program in the following folder

      •  c:\ode-0.11.1\roboSimu\DebugLib

   9. Double click the following file
      • arm1.exe
   10. You can see a robot arm.
   11. That’s all.  Enjoy my sample programs!

demu

The ODE book, Robot simulation – Robot programming with Open Dynamics Engine “, C language and the open source physics engine ODE (Open Dynamics Engine) , targetting the reader robot engineering has not been learned, the foundation of robot engineering you learn the method of programming that gradually.

Necessary knowledges are only mathematics of high school and C language of beginners’ class level. The lesson begins from falling of the apple, the wheel type robot, the robot arm, 4 leg robots and step-up to the lovely humanoid robot, Kensei-chan. Making a dynamics walking program is the last mission.

In the ODE book, you can learn how to make simulators which used 3D graphics shown above (they are all simulations in the ODE book) and you can also learn the basic of robotics. A physics engine like ODE is necessary to make games realistices, has becoming indispensable. It means that knowledge of robotics are necessary for a game developper.

Why don’t you try to control robots in the virtual space?

You can download my sample programs,  robosimu081003.zip, from here.

An AIBO, a humanoid robot for RoboCup, and me. (Copyright: The Hokkoku Shinbun, 2007)

Welcome to my web site !

My name is  Kosei Demura. I am an adviser of the RoboCup team in Yumekobo (Factory for Dreams and Ideas) at Kanazawa Insitute of Technology (KIT) in Japan, and also a professor in the Dapartment of Robotics, KIT.

RoboCup is one of the dream projects such as  Project Apollo.

The dream of RoboCup is as follows.

By mid-21st century, a team of fully autonomous humanoid robot soccer players shall win the soccer game, comply with the official rule of the FIFA, against the winner of the most recent World Cup. (quoted from the RoboCup official site)

Our RoboCup team, WinKIT,  has been participated in the Middle Size Robot League (MSL) in RoboCup since 1999. We are 3 times Vice World Champion from 2002 to  2004, and the Japan Champion in 2003.

From 2007, our team,  the demura.net team,  was participated in the humanoid league in RoboCup Japan Open.  Next year, we will plan to participate in the humanoid league in the RoboCup World Championship held in Suzhou, China.

I place RoboCup to a nucleus of my research and education. I would like to continue making a small step towards the RoboCup dream.

A virtual humanoid robot “Kensei-Chan”

I introduce my ODE related book , “Robot Simulation – Robot programming with   Open Dynamics Engine , (260pages, ISBN:978-4627846913, Morikita Publishing Co. Ltd., Tokyo, 2007)” by Kosei Demura, which is written in Japanese (sorry).

There are a lot of good text books about Robotics, such as, “Robotics – Vector Analysis of Mechanical System- (SHOKABO)” by Prof. Hirose, “Introduction to ROBOTICS – mechanics and control (Addison- Wesley) “  by Dr. John J. Craig, and so  on.

In addition, if the textbook regarding C programming language, many books have lined up into the book store.

So, I decided to write a textbook combines those two subjects. Open Dynamics Engine is used as the expedient to which as for this book in order fundamental theory of robotics to tie and programming organically, the money is not required and easily experiences robot programming.

This book aims that learning fundamental theory in Robotics and acuqiring the programming skill to realize that.

Unique features are as follows.

• The foundation of robotics and the practice book which can acuqire the programming skill
  

• Making robot sumulators, such as, wheeled robot (differential drive and omnidirectional drive), a robot arm, a 4 legged robot, a humanoid robot simulator, and  writing basic programs to control those robots. Furthermore, those programs are written in C language and can be operated under Windows, Linux and Mac OS X.

• You can program without the ODE english user guide.
• API index,  API inverse index are supported.
• About half of this book, i.e., 130 pages are articles (tutorial & manual function) regarding ODE.

• I sent some mails to Dr. Russell Smith who is the primary author of ODE.  He kindly permitted me quoting and reprinting from the Open Dynamics Engine User Guide.  If there is no ODE, this book being not to be born. Including  the sense of appreciation to Russ,  and in order to support the ODE project, I donate One US Dollar per book sale to ODE project. Morikita Publishing Co. Ltd. cooperated on this donation. In order to keep maintaining this kind of open source project,  I think that cooperation of many people is necessary. Man shall not live by bread alone, but man shall not live without bread.

I wish that a publisher would translate my book into English.

A sample screenshot of modified texures (details on RoboCon MagazineNo.50)

This is 19th article about ODE (Open Dynamics Engine) Tutorial. ODE is an open source physics libary, and it is widely used  in various game software, and simulators in research.

This time, I explain how to customize the drawstuff , the 3D graphics library, which has been attached to ODE with a free gift. Drawstuff being to be the very used OpenGL simple library is useful to also the study of OpenGL. You viewing one time source code, how, probably will be?

3 kinds of textures
In the draw staff just texture of 3 types which are shown in the rough sketch is used. As for these filesusingstandard ones which are called ppm (portable pixmap) format, it is under ode-0.8/drawstuff/textures. The user does not appoint the texture of the sky and the ground, it is applied automatically, but, using dsSetTexture (DS_WOOD), it sets the texture of the object. When cancelling setting, dsSetTexture (DS_NONE) is used.

• Texture of the sky:     Sky.ppm
• Texture of the ground:  Ground.ppm
• Texture of objects:  Wood.ppm

Texture of the sky

Texture of  the ground

Texture of objects

Note: It has converted texture in the upper figures to jpg format in order to indicate with the browser.

Modification method of texture
When using the GIMP, the GNU image maniplulation program, you can save the texture file as raw (raw) mode of ppm type, and overwrite the texture file on the original texture file. The new teture becomes effective. As for size sky.ppm 128×128 pixel, ground.ppm and wood.ppm has become 256×256 pixel.

Advanced modification
Being to be able to modify, it does, texture with this but, being boundary of the land and the sky continues to be the standard color grey a little it becomes matter of concern. In order to modify this color, it is necessary to rewrite the source code of drawstuff. Until now, the source code is rewritten, please try challenging also the one which you think that how it is awesome. The fact that the source code is customized steadily is Daigo taste of the open source.

• The file ode-0.8/drawstuff/drawstuff.cpp which modifies
  It meaning that 1123rd line glClearColor (0.5, 0.5, 0.5, 0) has decided boundary color, when it modifies 3 arguments (red component, green component and blue component) of beginning in the color which by your like, make does again to do ode it is reflected. Each color component of glClearColor is the range up to 1 from 0 as the point where you note.
• Sampling process of color
  If boundary color is possible, don’t you think? it is to do it is potato in the same type color as the texture of the land. The software of of free color of the place where we like on the picture is extracted is found if it searches with google, simply. As for me GetColor has been used, but if you search, you think that there is a variety.
• In order to gradate the horizon,
  In the actual world as for horizon with such as dust in the atmosphere being visible in clearing it is rare. In order to simulate this, if there is a fog, the horizon becomes blurred, don’t you think?. In order to actualize this, if the comment of 1016th line is removed from the 1006th line of drawstuff.cpp, it is OK. However, there is a problem with some graphics boards.

This time with this end.

This is 18th article about ODE (Open Dynamics Engine) Tutorial. ODE is an open source physics libary, and it is widely used in various game software, and simulators in research.

This time, I explain the method of speed up a simulation without using the drawstuff, the 3D graphics engine, which is attached to ODE.

Drawstuff based on OpenGL is not the portion of ODE, it is only provided to show demo programs. I think drawstuff is very good for education purpose, because the library is very simple and it helps to study OpenGL.

The method of not using drawstuff is very simple. In the test program dsSimulationLoop is called in main function. This part to call the drawing loop, because it draws with each step of simulation and event processing from the keyboard. Functions of drawstuff begin with the letter “ds”.

That is, do not call dsSimulationLoop and other functions of drawstuff. Please see the following sample codes.

With drawing

void simLoop (int pause)
{
  // Write some necessary codes here
  dSpaceCollide(space,0,&nearCallback);
  dWorldStep(world,0.01);
  dJointGroupEmpty(contactgroup);
  const dReal *pos=dBodyGetPosition(apple);
  const dReal *R=dBodyGetRotation(apple);
  dsDrawSphere(pos, R, r);
}

int  main(int argc, char *argv[])
{
  // omission
  dsSimulationLoop(argc, argv, 640, 480,  &fn);
  // omission
}

Without drawing

static void simLoop (int pause)
{
  // Write some necessary codes here
  dSpaceCollide(space,0,&nearCallback);
  dWorldStep(world,0.01);
  dJointGroupEmpty(contactgroup);
  // const dReal *pos=dBodyGetPosition(apple);
  // const dReal *R=dBodyGetRotation(apple);
  //dsDrawSphere(pos, R, r); // without drawing
}

int  main(int argc, char *argv[])
{
  // omission
  while (1) {
    simLoop(0);  //  the argument must set to 0
  }
  // omission
}

To be continued.

This is 17th article about ODE (Open Dynamics Engine) Tutorial. ODE is an open source physics libary, and it is widely used  in various game software, and simulators in research.

This time it explains concerning the method of moving the position of COG (center of gravity). API, dGeomSetOffsetPosition was introduced from ODE0.6, shifting the position of center of gravity extremelysimply in comparison withthe former method of usingthe Geometry Transform object whichlast year is introduced with ODE lecture reached the point where it can set.

• API about offset the positon of geometry

So, the tumbler in the upper figure is introduced as a sample program.Please download the source code from here.With this example, it is suitable to the body of the small priest sphere (mass 10kg and radius 0.4m) from the center of sphere under 0.4m to set center of gravity, because as for mass of the sphere which is suitable to the head there is only 1g, this small priest by all means rises. Concretely, with dBodySetPosition from the center of sphere radius amount (0.4m) shifting balance station under, it sets, that was shifted the quantity which (the offset, here dz) it has set with dGeomSetOffsetPosition.

When the f key and the j key are pushed from the keyboard, to the tumbler it can add to left and right direction the power of 100N, but being to be a restitutive force, it rises, it requires you can verify.

// koboshi2.cpp by Kosei Demura 2007-1-20
#include <ode/ode.h>
#include <drawstuff/drawstuff.h>;
#ifdef dDOUBLE
#define dsDrawSphere dsDrawSphereD
#endif
#define MAX_CONTACTS 4
static dWorldID world;
static dSpaceID space;
static dGeomID  ground;
static dJointGroupID contactgroup;
dsFunctions fn;
typedef struct {
  dBodyID body;
  dGeomID geom;
  dReal   radius;
  dReal   length;
  dReal   mass;
} MyLink;

MyLink   head, torso; //  head. torso of
dJointID joint;　　　　　//  a fixed joint between a head and a torso
static void nearCallback (void *data, dGeomID o1, dGeomID o2);
{
  int i;
  // exit without doing anything if the two bodies are connected by a joint
  dBodyID b1 = dGeomGetBody(o1);
  dBodyID b2 = dGeomGetBody(o2);
  if (b1 && b2 && dAreConnectedExcluding (b1,b2,dJointTypeContact)) return;
  dContact contact[MAX_CONTACTS];   // up to MAX_CONTACTS contacts per box-box

  for (i=0; i < N; i++) {
    contact[i].surface.mode = dContactBounce | dContactSoftCFM;
    contact[i].surface.mu = 1.0;                   // Coefficient of friction
    contact[i].surface.bounce = 0.01;          //  bounce parameter
    contact[i].surface.bounce_vel = 0.01;   //  minimum incoming velocity necessary for  bounce
    contact[i].surface.soft_cfm = 0.00001;
  }

  if (int numc = dCollide (o1,o2,MAX_CONTACTS,&contact[0].geom,sizeof(dContact))) {
    for (i=0; i < numc; i++) {
       dJointID c = dJointCreateContact (world,contactgroup,contact+i);
       dJointAttach (c,b1,b2);
    }
  }
}

static void drawSphere(dGeomID g)
{
  if (!g) return;
  const dReal *pos = dGeomGetPosition(g);
  const dReal *R = dGeomGetRotation(g);
  dsDrawSphere(pos,R,dGeomSphereGetRadius(g));
}

static void simLoop (int pause)
{
  dSpaceCollide(space,0,&nearCallback);
  dWorldStep(world,0.01);
  dJointGroupEmpty(contactgroup);
  dsSetColor(1.0,0.0,0.0);
  drawSphere(torso.geom);
  dsSetColor(1.0, 0.0, 0.0);
  drawSphere(head.geom);
}

void start()
{
  static float xyz[3] = {   3.5,0.0,1.0};
  static float hpr[3]  = {-180.0,0.0,0.0};
  dsSetSphereQuality(3);
  dsSetViewpoint(xyz,hpr);
}

// Create an object
void createDaruma()
{
  dMass m,m1;
  dReal x0 = 0.0, y0 = 0.0, z0 = 0.4;
  dReal dx = 0.0, dy = 0.0, dz = 0.4;  // offset
  // torso: offset the center of gravity
  torso.body   = dBodyCreate(world);
  torso.radius = 0.4;　　//  radius
  torso.mass   = 10.0;　//  mass

  dMassSetZero(&m);
  dMassSetSphereTotal(&m,torso.mass,torso.radius);
  dBodySetMass(torso.body, &m);
  torso.geom = dCreateSphere(space,torso.radius);
  dGeomSetBody(torso.geom,torso.body);

  // Set the COG under the radius of the torso (sphere)
  dBodySetPosition(torso.body, x0, y0, z0 - dz);

  //This way, in order geometry of the body (form) to be buried in the land, it sets with respect to radius amount of sphere. Center of gravity of sphere moves under radius amount due to this movement, the body has restitutive force.
  dGeomSetOffsetPosition(torso.geom, 0, 0, dz);

  //  head
  head.body = dBodyCreate(world);
  head.radius = 0.3;
  head.mass   = 0.001;
  dMassSetZero(&m1);
  dMassSetSphereTotal(&m1,head.mass, head.radius);
  dBodySetMass(head.body,&m1);
  head.geom = dCreateSphere(space,head.radius);
  dGeomSetBody(head.geom,head.body);
  dGeomSetPosition(head.geom, x0, y0, z0 + torso.radius + head.radius);

  //  fixed joint (between the head and the torso)
  joint = dJointCreateFixed(world, 0);
  dJointAttach(joint, torso.body,head.body);
  dJointSetFixed(joint);
}

void command(int cmd)
{
  switch(cmd) {
   case ‘f’:　// When the f key is pushed, the power of 100N is added to forward of x axis
                dBodyAddTorque(head.body,  100, 0, 0); break;
   case ‘j’:　// When  the j key is pushed, -100N power is added to forward of x axis
     dBodyAddTorque(head.body, -100, 0, 0); break;
   }
}

void  setDrawStuff() {
  fn.version = DS_VERSION;
  fn.start   = &start;
  fn.step    = &simLoop;
  fn.command = &command;
  fn.stop    = NULL;
  fn.path_to_textures = "../../drawstuff/textures";
}

int main(int argc, char **argv)
{
  setDrawStuff();    // Set of drawing function
  world = dWorldCreate();　// create a dynamic world
  space = dHashSpaceCreate(0);　// 　create a collision space
  contactgroup = dJointGroupCreate(0);　// for collision calculation
  dWorldSetGravity(world,0,0,-9.8);　// set a gravity of the dynamic world
  ground = dCreatePlane(space,0,0,1,0);　//  set a ground
  createDaruma();　// create a Daruma
  dsSimulationLoop (argc,argv,640,480,&fn);　//  simulation loop
  dSpaceDestroy(space);     //  destory the collision space
  dWorldDestroy (world); 　//  destroy the dynamic world<
  return 0;
}

My article, Open Dynamics Engine Petit Camp in RoboCon Magazine(No.50), finished  February 15th, 2007. This time in order the world of ODE is made to enjoy it has publishing to the color page, method of using the draw staff of attachment such as background and modification method of the texture file to main explains, concerning the control of simple biped walking.

A screen shot of the sample program.   The Petit Waru (evil) Biped Robot: Warusa P01

Furthermore, the SF like robot which is the upper figure as a sample program being to designate  a biped robot, Warusa P01, please read the article on RoboCon Magazine if you have interest.

Control of simple biped walking to be mounted by the program, because it can get from link below, please play freely. However, there is no warraty for  the program. It is the mere sample, you can not enjoy it like a game. The program has bugs, so please do not redistribute it. Furthermore, method of playing is not completed, but the article of  the RoboCon magazine or please see the command function in  the source code.

• Sample program (Petit Waru Robot Simulator) download

• Warusap070221.lzh (with lzh compression)

• Warusap070221.tgz (with tgz compression)
• Two files above compressed method just are different, but content are same ones.

By the way, as for name Warusa of this robot P01 gun Walther P38 which animation “Rupin The Third” has regularly used the letter  it is something which designates. For the design priority it is not faced to the control of walking. In the first place, being not to be easy it does that it can point to smooth 2 foot walking to the robot of the structure where the crotch joint has been attached to the immediate side of the body. Because it does not tune either parameter sufficiently, somehow you walk it is level. Tuning parameter, please try making walk more smoothly.

Furthermore, because you sent makefile for Mac OS X from Mr. Yamada of the University of Ryukyu, in the above-mentioned file is inserted. Being to be the name, makefile.osx copying in makefile, please use. It meaning that from ODE0.8 libdrawstuff.a stops being copied by /usr/local/lib with make install, after by your you copying in /usr/local/lib, please use. In addition, also drawsutff corresponded to the carbon and there is no X11 and reached the point where it moves on OS X. It is something which extremely has become the easy chin. Information above is all information from Mr. Yamada. My iMac was saved the interior being to have converted, truly.

[ Errata ]
There is P69 of   RoboCon Magazine No.50, “Petit Lecture: What is a rotation matrix? “With as for the element which corresponds to r33 of revolution queue R [ 0 ] is not and R [ 10 ] is. Formula below is correct answer. When you verified in RoboCon Magazine, this mistake seems that occurred at stage of printing from stage of compilation separated. It is not my mistake, but borrowing this place, the correction tide you apologize.

[Acknowledgement]
It becomes last, but serialization of  RoboCon Magazine became the valuable experience for me. Thank you for taking care very much in Ms. Takahashi taking charge of compilation. In addition, reading my article, the method which can begin ODE to be, because and others it is the plain gauze, or you wrote, being something which was, it does. In addition, the opportunity will be made and being to think, that the article will be contributed to also the other magazine, also in the future we ask may.

As for December 16, 17 in 2006, there was the year-end party of KIT at the Katayama Tsu hot spring which from Kanazawa by the car is the place about of 1 hour. At this year-end party is large-scale ones where all school personnel of KIT crowds around all. At the university this way the place where year-end party of all-campus scales is done is very much unusual, it is the unique place of KIT.

Well, No.49 of RoboCon Magazine was sold December 15th (the gold). The serialization which moves the petit version HRP-2mof HRP2 Promet where as for RoboCon Magazine the funny article was many, from No.49 was developedwith the productentire researchChorometstarted. 1st as for time Okano is written with the subject, “real time processing programming which uses ARTLinux”.

My serialization time becomes 3rd. It is the story that this time as recognized even with the high school student, it explains opposite kinematics, to the kinematics which is the basis in the basis of robotics that mounts on the robot arm petit simulator, verifies operation. As for details please readRoboCon Magazine.

Furthermore, because with RoboCon Magazine the space is limited, you cannot explain in detail. In order in this page to supply that, in order to be able to download the sample program. Please download freely.

• Free download sample programs !

• 3 joint robot arm petit simulator (arm3.lzh)
  
  
  
  A 3 DOF  robot arm petit simulator

• Kinematics of 2 joint robot (arm2.lzh)

• Opposite kinematics of 2 joint robot (arm2IK.lzh)
  

  A 2 DOF robot arm petit simulator (Inverse kinematics)
  
  

Please ask the person who is not understood be possible in addition, to read serialization by all means in this page. We wait also thought and opinion etc..

A World of robot arms.