Balancing Quadraped - Like Big Dog, but Smaller

Other Hardware Robotics
1

Does anyone know about the hardware/software that goes into building a robot like Boston Dynamic's Big Dog, Little Dog, Cheetah, or other similar quadrapeds? I know that they must be using some high quality gyros and other sensors. They probably also are prototyping their own PCBs and other electronics.

I am just noodling around an idea right with no intention of building it soon. The scale would be quite a bit smaller than the Big Dog. House-cat sized. It would be for indoor use, so it would have to carry it's own power supply. I also will not consider a fuel-based generator as they are much too noisy. The goal is to have a house cat that doesn't eat or poop, it only loves...

This is a brainstorming session.
Money is not an option in this willy-nilly world of theory. But links to actual parts/code would be appreciated!

Some questions to consider. Please quote and answer what you can:

  • Can a robot be as cute and cuddly as a real cat? (How to avoid the uncanny valley? LOL)
  • What would it take to achieve realistic movement? (Physics simulations? Character animation, motion tweening?)
  • What could i use for realistic skin and fur?
  • Could something with this kind of balancing, walking, and reaction capability be built with Arduino(s)?
  • Would processor speed or memory be an issue with Arduino boards?
  • What types of servos/motors/sensors would best suit this application? Think fast, quiet, small...
  • Are there any Arduino code precedents for quadrapeds utilizing gyros?
  • Are there any automated navigation code precedents for Arduino? (Using LIDAR, RADAR, SONAR, etc.)
  • What other questions should I be asking if I want to take this from theory, to reality?

Thank you for your time and consideration!
Nate

http://www.bostondynamics.com/img/BigDog_IFAC_Apr-8-2008.pdf

2

Writing code for quadrupeds is probably 10X harder than for hexapods, due to the Q4 requiring dynamic-stability gaits rather than static-stability [for H6].

You can find a lot of very good info if you look for academic papers about "Little Dog" rather than the others.
http://scholar.google.com/scholar?hl=en&q=little+dog+quadruped+robot
See also youtube videos for s.w. in action.
https://www.youtube.com/results?search_query=little+dog+robot

Also, basically if you make the thing look like a real "robot", rather than something resembling a bizarre imitation of some kind of animal [or even worse, a human], you can easily avoid the Uncanny Valley.

The robots [ie, Amblers] are "cute", the animatronics figures are slightly bizarre, but those are intended for museum exhibits.

Truly creepy, lost in the bottomless pit of the UV:

[jelajahunik: Wanita Cantik Ini ternyata ROBOT ...
Elfoid: Creepy Robot Cell Phone (Video) | TechCrunch

https://www.youtube.com/watch?feature=player_embedded&v=UWlzMIl7E48

BTW, the EPFL people are true masters of the craft. Track down and read their papers. Robot Cub, however, is right on the lip of the UV, as far as I am concerned, LOL.

3

I just noticed that this post should have gone in the "Project Guidance" forum. Any mods want to move it for me? Thanks!
Nate

4

Well, this IS the robot section. However, you might put a link over there per your last msg [use a slightly different Topic line], and suggest people come to this thread. Or else send a msg to a moderator to move this thread.

5

Thanks for the links!

6

oric_dan:
BTW, the EPFL people are true masters of the craft. Track down and read their papers. Robot Cub, however, is right on the lip of the UV, as far as I am concerned, LOL.
http://biorob.epfl.ch/

That's what I'm talking about!! Awesome! Thanks again.

7

the way the program these kind of balancing organic creatures is through the use of algorithms, this applies to anything from cats to quad-copters (there is a great ted talks about this here Raffaello D'Andrea: The astounding athletic power of quadcopters | TED Talk )

the reason they use this is because it is how living animals work, we try something, adjust our method, and try again. it is, in its simplest for trial and error, think about practicing for throwing a baseball, you do it hundreds of times, each time getting it a little wrong, but then getting a little better.

if you watch the ted talk, they talk about control theory, and differential equations, these are not really necessary, because as I said, this is just advanced trial and error.

the way I see this is to do it in two ways you could do it as trial and error, program in a correction to a given error, for example. tipping left, has a correction of splaying both legs on the left side a given amount that is proportional to the roll amount (measured by a gyro) you can then observe if it works and adjust the reaction (in this case the proportion between the roll and the splay of the left legs, and try again

or you could program the arduino to do this for you, you could program reactions to it for a variety of circumstances, for example, a rotation in each direction could be countered, if you rotate left, splay left legs, if you rotate right, splay right legs, if you tip forward lower the back legs, if you tip back lower the front legs, and these would all be tied to a proportion of the rotation in that direction
then you would have the machine adjust thoose proportions, if it tips forward, then reacts but still falls, it automatically increases the proportion of how much the back legs are lowered, so you pick it up, set it on its feet, and have it continue on, and the next time it tips forward, it will react better

the implication of this is that you are creating a machine that will learn, you can teach it to do any number of things, you could add code that would allow you to add a merit/demerit system, if it does something you like, you tap a button, and it will be more likely to do that thing again, if it does something you don't like, you smack it, and it will be less likely to do that thing again, of course this would also require you to program in certain actions.

a system like this would be difficult and complex, but if you have the time, the actual code would not be that bad, this is they future of robotics, robots that learn, improve and get better, creating the background code or framework for this system is difficult, but this system could serve you well for many applications

this may all be way more complicated than a task like this requires but if the goal is to learn (and it always should be) then this is a great foray into the way advanced life-like robots function

8

the implication of this is that you are creating a machine that will learn,

This is great info! Thanks Victor! I am just breaking into this branch of dynamic programming and learning algorithms. I am trying to locate some kind of framework to start with. Open source is the way to go. If I can, I will create a plugin for Blender that can calculate walking gaits for my model, similar to the way Webots does for the pros. After talking with Auke Ijspeert, Peter Eckert, and the EPFL team behind Cheetah Cub, I found out that much of their "learning" was simulated using Webots. Having an open source platform to support "learning" could open up the quadruped field to a lot more people (like me!).

So does anyone know of some existing code framework for building learning robots?

Thanks all! :slight_smile:
Nate

9

Some things I found:
http://wiki.blender.org/index.php/Community:Science/Robotics

Blender does have a robotics community. Their wiki is just in the infant stages.

http://www.orocos.org/kdl
This project seems to have a good engine for processing kinematics. I am not sure how well it will do with the kind of squishy/compliant features I am thinking of. It's a start! :slight_smile:

http://ulgrobotics.github.io/trs/
This may also be a good option for an open source simulator. I am not sure that it will handle kinematics, gaits, or learning algorithms.

http://creativemachines.cornell.edu/aracna
Now this is interesting! An open source hardware platform!

I am still on the hunt for an open-source code-base for robot learning. Something to get me started with managing gaits and other integrated movements. I have reached out to a few people involved with the Cheetah cub project and they have been kind enough to provide me with some basic specs and their research papers.
Thanks again, keep looking!
Nate

10

https://code.google.com/p/arbotix/wiki/NukeTuning
https://code.google.com/p/arbotix/wiki/PyPose

Using these two tools together I may be able to get very close to what I need.

Keep the suggestions coming!
Nate

11

thoose two tools will help but they won't do the "squishy" code for you, doing this on an arduino may be difficult, because it cannot do tasks, so I cannot run multiple adjustments at once( think tasks) so you are limited to the processing speed of the arduino, which may or may not be a problem

12

here is some framework code, it is unfinished, it doesn't do walking, just self leveling, it also at this point only corrects for roll errors, but the framework for the pitch corrections are also there, i just didn't finish that section as it is very similar to the roll section. this should give you what you need to get started.

right now the corrections are very harsh, it will start the learning process by correction and error by splaying its legs 45 degrees (in the end this may only need to be a couple of degrees) you can change the starting value ( a proportion) in the code, and also adjust how fast it "learns"

#include <Servo.h>

Servo flLeg;  //front left leg servo
Servo frLeg;  // front right leg servo
Servo blLeg;  //back left leg servo
Servo brLeg;  //back right leg servo
// theese are gyros determaning the angle of roll, pitch and yaw,
//in this example y is roll,x is yaw, and z is pitch,
//we realy dont need yaw for this but it will be included at some
// point to make the thing turn and go straight 
int xgyro = 1;
int ygyro = 2;
int zgyro = 3;
//the numbers are the analog pins you out theese into, choose any

int roll;
int yaw;
int pitch;
void setup() {
  //the pin numbers are random, they must be digital 
  //outputs that are PWM cabable, theese ones will
  //vary based on your arduino model
  
flLeg.attach(1);
frLeg.attach(2);
blLeg.attach(3);
brLeg.attach(4);

  int fl = 90;
  int fr = 90;
  int bl = 90;
  int br = 90;
  
//variable for the position of each servo  



  
  int pr = 4;
  //proportion of roll  for ajustments
  int pp= 4;
  //proportion of pitch for adjustments
  
  int roll1;
  int roll2;
  //used to record the roll before and after correction to see if it worked
}

void loop() {
  //servo value less than 90 will be tilted forwar, ones greater than 90 will be tilted back
  //so 180 and 0 will both be flat on the ground


  //this code will not make it walk, it will just make it stand straight
  //and adjust position
  

 
 roll = analogRead(ygyro);
 pitch = analogRead(zgyro);
 
   if(roll < 0){
     roll1 = roll;
     fl = fl - (roll/pp);
     bl = bl + (roll/pp);
   }
   
   if(roll > 0){
      fr = fr - (roll/pp);
     br = br + (roll/pp);
   }
 if(abs(roll) < 5){
   //returns robot to standing up right if roll has been corected
   fl = 90;
   fr = 90;
   bl = 90;
   br = 90;
 }
 

 flservo.write(fl);
 frservo.write(fr);
 blservo.write(bl);
 brservo.write(br);
  roll2 = roll;
  
  //this section changes how much your correction is, it does this by comparing the roll before the correction and after the correction and seeing if it corrected to little or too much and then ajusts
  // the proportion by which you correct
  
  
  if((abs(roll1) - abs(roll2)) < 0)
  //you can change the amount pr is changed by on each iteration, larger numbers will cause it to ajust faster but you wont be as accurate, smaller numbers will be more accurate but change will be slower
  pr = pr - .001;
  }
  
  if(roll1 > 0 && roll2 < 0){
   pr = pr +.001; 
  }
   if(roll1 < 0 && roll2 > 0){
   pr = pr +.001; 
  }
13

Cool! Thanks for the nudge in the right direction. I had been thinking about the ability to process multiple threads. A faster CPU may be able to support the kind of software we are talking about. I will think about this for a while and report back if I make any developments.

Please keep the ideas coming! :slight_smile:
Nate