Hexapod source code

As per request, here is the code to my arduino hexapod. Please note that I am using an external servo controller, so this code simply sends the servo positions via a serial connection.

More Info (+ youtube video)

I'll try to comment it more fully (and refactor) when finals are over.

PS - it seems blogger is cutting off the right side of the code... :( You should copy/paste into an editor to see the ends of those arrays

/* Reference:

Horizontal movement:
Right side - INCREASING pulse width moves leg toward BACK
Left side - DECREASING pulse width moves leg toward BACK

Vertical movement:
Right side - DECREASING pulse moves leg DOWN
Left side - INCREASING pulse moves leg DOWN

// -------------------------------------------
// Horizontal Max & Min
// -------------------------------------------

#define HorzMid 1515

// Front Right:
#define frHorzMax 1815
#define frHorzMin 1400

// Middle Right
#define mrHorzMax 1715
#define mrHorzMin 1415

// Back Right
#define brHorzMax 1835
#define brHorzMin 1300

// Front Left
#define flHorzMin 1375
#define flHorzMax 1715

// Middle Left
#define mlHorzMin 1344
#define mlHorzMax 1555

// Back Left
#define blHorzMin 1135
#define blHorzMax 1675

// -------------------------------------------
// Vertical Max & Min
// -------------------------------------------
// Right side
#define rVertMax 2300
#define rVertMid 1776
#define rVertMin 900

// Left Side
#define lVertMax 2300
#define lVertMid 1494
#define lVertMin 900

// -------------------------------------------
// Servo Controller Channels:
// -------------------------------------------
// Horizontal Movement:
#define frHorz 0 // Front Right
#define flHorz 1 // Front Left
#define mrHorz 2 // Middle Right
#define mlHorz 3 // Middle Left
#define brHorz 4 // Back Right
#define blHorz 5 // Back Left

// Vertical Movement:
#define frVert 6 // Front Right
#define flVert 7 // Front Left
#define mrVert 8 // Middle Right
#define mlVert 9 // Middle Left
#define brVert 10 // Back Right
#define blVert 11 // Back Left

// Load Servo data into arrays
int servoNumber[12] = {brHorz, flHorz, mrHorz, blHorz, frHorz, mlHorz, brHorz, flHorz, mrHorz, blHorz, frHorz, mlHorz};
int servoHorzDirection[12] = {-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1};
int servoVertDirection[12] = {-1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1};
int servoVertMid[12] = {rVertMid, lVertMid, rVertMid, lVertMid, rVertMid, lVertMid, rVertMid, lVertMid, rVertMid, lVertMid, rVertMid, lVertMid};

// -------------------------------------------
// Misc Variables
// -------------------------------------------

int pulse = 0; // Amount to pulse the servo
int potPos = 0;

// -------------------------------------------
// Run-once Setup function
// -------------------------------------------
void setup() {

// -------------------------------------------
// Loop-forever Function
// -------------------------------------------
void loop() {

// walk forward faster and faster

// relax

// walk backward faster and faster

// relax


// -------------------------------------------
// Reset All Servos
// -------------------------------------------
void resetAllServos() {
moveServo(frVert, rVertMid);
moveServo(mrVert, rVertMid);
moveServo(brVert, rVertMid);

moveServo(flVert, lVertMid);
moveServo(mlVert, lVertMid);
moveServo(blVert, lVertMid);

moveServo(frHorz, HorzMid);
moveServo(mrHorz, HorzMid);
moveServo(brHorz, HorzMid);

moveServo(flHorz, HorzMid);
moveServo(mlHorz, HorzMid);
moveServo(blHorz, HorzMid);


// -------------------------------------------
// Move a Servo
// -------------------------------------------
void moveServo(int ServoPin, int PulseWidth) {
Serial.print(" #");
Serial.print(ServoPin); //which servo to move
Serial.print(" P ");
Serial.print(PulseWidth); // the pulse width to send

// -------------------------------------------
// Set Amount of Time Servos Take to Move
// -------------------------------------------
void setMoveTime(int moveTime) {
Serial.print(" T "); //temp command (time = 1 second)

// -------------------------------------------
// Walk
// -------------------------------------------
void walk(int walkSpeedAndDirection) {
int intermission = 150; // delay between each part (in ms)
int horzDistance = walkSpeedAndDirection; // Distance to have each leg forward (actual distance of one
// step is 2*horzDistance because the leg moves horzDistance forward and backward)
int vertHeight = 200; // Total height of each step

int i;
for (i=5; i!=-1;i--) {
//Vertical Servo1 Up:
moveServo((servoNumber[i] + 6), (servoVertMid[i] + (servoVertDirection[i] * vertHeight)));
//Horzizontal Servo1 to 2/4
moveServo(servoNumber[i], HorzMid);

//Vertical Servo2 Down:
moveServo((servoNumber[i+1] + 6), servoVertMid[i+1]);
//Horizontal Servo2 to 4/4 (front)
moveServo(servoNumber[i+1], HorzMid + (servoHorzDirection[i+1] * horzDistance));

//Horizontal Servo3 to 3/4
moveServo(servoNumber[i+2], HorzMid + (servoHorzDirection[i+2] * (horzDistance/2)));

//Horizontal Servo4 to 2/4 (midpoint)
moveServo(servoNumber[i+3], HorzMid);

//Horizontal Servo5 to 1/4
moveServo(servoNumber[i+4], HorzMid - (servoHorzDirection[i+4] * (horzDistance/2)));

//Vertical Servo6 Down:
moveServo((servoNumber[i+5] + 6), servoVertMid[i+5]);
//Horizontal Servo6 to 0/4 (back)
moveServo(servoNumber[i+5], HorzMid - (servoHorzDirection[i+5] * horzDistance));

//tell the servo controller to execute the commands and wait for the servos to finish

Horizontal movement:
Right side - INCREASING pulse width moves leg toward BACK
Left side - DECREASING pulse width moves leg toward BACK

Vertical movement:
Right side - DECREASING pulse moves leg DOWN
Left side - INCREASING pulse moves leg DOWN

Dvd::Rip Queue 0.1 Beta

hello all,

I havn't posted in a while but I have written a little program to help with ripping DVDs. It's for use with DVD::Rip by Joern Reder. And it queues up the projects so you can leave your computer running over night.

The program is written in python and pretty thoroughly commented (though all in one file). I hope someone finds this useful. Note: I applied for a SourceForge project space, bur for now, here is the code:

MD5: 0ab561032354c2e2261838524637d65f

update: The project is now on sourceForge. Please submit bugs as you find them

The program is licensed under the GPLv3 so I encourage you to do what you like with it. And Please feel free to comment if you have any problems, I'll respond quick, promise :)

I havn't forgotten about you!

Hello all,

I havn't forgotten about this blog, I've just been really busy learning lots of interesting things!

Also, doing school work, trying to build up my recording studio (shameless plug), and workin on that hexapod.

Speaking of which, here is a short video of it in operation:

This bot was built using the following components:

  • Arduino Decimilia w/protoshield (from adafruit)
  • Lynxmotion SSC-32 Servo controller
  • 6 - Hitec HS-645MG Servos
  • 6 - Hitec HS-322HD Servos
  • 6 - sets of pan/tilt servo brackets
  • ~2 feet of 1/2" PVC Tubing
  • lots of little miscellaneous screws, washers, nuts, and bolts ammounting to around $5 at your local hardware store
I'll do a proper writeup and post code when I get some decently complex functionality out of it...

Right now I'm just writing functions for things like walking that take speed, direction, and turning radius into consideration.

I'm trying to make it nice and simple to use so I can start writing AI without having to relearn my own code (that means comment galore)

Next up:
Adding sensors to give the little lady an idea of her surroundings. Did I mention this particular hex is a gentle fun-loving young female who enjoys walks on the beach and firefighters? Her name is baby, and I have to say she's definately entered the awkward teenaged years about now (notice stumbling all over the computer equipment and cables in the video).

Arduinos & servos & batteries: oh my!

So you want to control more than 2 servos with your arduino... you're in luck! I'm about to tell you how to do it!

A little bit about servos:

  1. Whether you're using a separate power supply for the servo or not, all grounds (black servo wire) must be connected together. That includes the ground of the arduino, the ground of the servo, and the ground (negative side) of the battery or power supply.

  2. Using a separate battery to power the servos is usually a good idea if you're using more than 2 servos. Otherwise you risk damaging your arduino.

  3. Most servos expect between 4.5V and 6V on the red lead (center pin), and a signal on the yellow or white lead to indicate position. This signal is called Pulse width modulation (PWM)
Pulse width modulation seems more complicated than it is. Here's how it works.
OK, let's say you have:
  • 6 servos
  • Arduino with proto-shield
  • A battery of ample size to power the servos
The PWM signal I mentioned earlier works like so... Every 20 milliseconds (20ms) the signal goes from 0 Volts (Ground) to 5 Volts for a certain length of time, usually 900 - 2400 microseconds. For most servos 1500 us (microseconds) is the middle of the servo's operational range

so here's how you'd hook up the first servo:

Now the servo has power, everything is grounded, and we're all set to start telling the servo what to do... Looks like we need to write some code! If you're not familiar with programming there is a great tutorial from ladyada. Otherwise... just use the Reference Page when you're unclear on something.

First we need to define some constants. This makes it easy to read the code, and also lets you change the value without going through all your code:
#define servoPin 1
Now whenever a function requires the pin number of the servo, we'll put servoPin instead.

The next thing we need to do is create two functions. They're required and without them nothing will happen. They functions are called setup and loop:
void setup() {


void loop() {

First the arduino runs the function called setup one time then proceeds to run the funtion loop over and over until the arduino is turned off. We're going to use the setup function to set Digital pin 1 as an output since that only needs to be done once.
void setup() {
pinMode(servoPin, OUTPUT);
Now we need to send the servo a pulse every 20ms so here's how to do it: We need a variable to store the time of the last pulse. We'll call it lastPulse. We need to declare it outside the functions because if you declare it inside the setup function the loop function won't be able to see it; this is called variable scope. I'm going to put the variable declaration just above the setup function:
long lastPulse = 0;

void setup() {
Now we just check if 20ms have passed, and if they have, send a pulse to the servo:
void loop() {
if (millis() - lastPulse > 20) {
The millis() function is essentially a timer. It tells you how much time has passed since the arduino was turned on. if the last pulse happened at 20 ms, and it's currently 35 ms... the arduino will skip the loop and try again, whereas if the last pulse was as 20 sec and it's currently 41ms the arduino will run the code inside the brackets.

Now it's time to send the pulse!
digitalWrite(servoPin, HIGH);
digitalWrite(servoPin, LOW);
The first digitalWrite() sets pin 1 to high (5V), which begins the pulse. It then waits the duration of the pulse width, 1500us in this case, and then sets pin 1 back to low (0v/Ground). There's your pulse!

One more thing: you need to save the time at the time you sent the pulse so we know how long to wait before we send another:
Here's the program so far:
#define servoPin 1

long lastPulse = 0;

void setup() {
pinMode(servoPin, OUTPUT);

void loop() {
if(millis() - lastPulse > 20) {

digitalWrite(servoPin, HIGH);
digitalWrite(servoPin, LOW);
Now we have some solid code to make one servo move to the middle of it's range and stay there.

To add the other 5 servos you just hook them up to the 6V Battery in parallel, while making sure to keep everything grounded. Then you hook up each servo's PWM lead to it's own digital i/o pin.

Lets say we want to set each servo to different set values:
Servo 1: 1000us
Servo 2: 1200us
Servo 3: 1400us
Servo 4: 1600us
Servo 5: 1800us
Servo 6: 2000us

Now the code is:
#define servo1Pin 1
#define servo2Pin 2
#define servo3Pin 3
#define servo4Pin 4
#define servo5Pin 5
#define servo6Pin 6

long lastPulse = 0;

void setup() {
pinMode(servo1Pin, OUTPUT);
pinMode(servo2Pin, OUTPUT);
pinMode(servo3Pin, OUTPUT);
pinMode(servo4Pin, OUTPUT);
pinMode(servo5Pin, OUTPUT);
pinMode(servo6Pin, OUTPUT);

void loop() {
if(millis() - lastPulse > 20) {

digitalWrite(servo1Pin, HIGH);
digitalWrite(servo1Pin, LOW);

digitalWrite(servo2Pin, HIGH);
digitalWrite(servo2Pin, LOW);

digitalWrite(servo3Pin, HIGH);
digitalWrite(servo3Pin, LOW);

digitalWrite(servo4Pin, HIGH);
digitalWrite(servo4Pin, LOW);

digitalWrite(servo5Pin, HIGH);
digitalWrite(servo5Pin, LOW);

digitalWrite(servo6Pin, HIGH);
digitalWrite(servo6Pin, LOW);
Not very elegant... but it works.

What we could do is write a function to send the pulse:
void sendPulse(int pinNumber, int pulseWidth) {
digitalWrite(pinNumber, HIGH);
digitalWrite(pinNumber, LOW);
Now the loop function looks like this:
void loop() {
if(millis() - lastPulse > 20) {

sendPulse(servo1Pin, 1000);
sendPulse(servo2Pin, 1200);
sendPulse(servo3Pin, 1400);
sendPulse(servo4Pin, 1600);
sendPulse(servo5Pin, 1800);
sendPulse(servo6Pin, 2000);
That's much better!

Here's the finished program... happy coding!
#define servo1Pin 1
#define servo2Pin 2
#define servo3Pin 3
#define servo4Pin 4
#define servo5Pin 5
#define servo6Pin 6

long lastPulse = 0;

void setup() {
pinMode(servo1Pin, OUTPUT);
pinMode(servo2Pin, OUTPUT);
pinMode(servo3Pin, OUTPUT);
pinMode(servo4Pin, OUTPUT);
pinMode(servo5Pin, OUTPUT);
pinMode(servo6Pin, OUTPUT);

void loop() {
if(millis() - lastPulse > 20) {

sendPulse(servo1Pin, 1000);
sendPulse(servo2Pin, 1200);
sendPulse(servo3Pin, 1400);
sendPulse(servo4Pin, 1600);
sendPulse(servo5Pin, 1800);
sendPulse(servo6Pin, 2000);

void sendPulse(int pinNumber, int pulseWidth) {
digitalWrite(pinNumber, HIGH);
digitalWrite(pinNumber, LOW);

Next time I'll be posting an example of how to use external input to control the servos!

Basic Stamp vs Arduino

Lots of reviews with similar names to this one say, "here's the info... you decide." Well I'm not going to do that... I'm going to name a winner, so don't touch that dial!

Basic Stamp:
Price: $119
Open Source: No
Awesome: eh...

Price: $32
Open Source: yes
Awesome: yes

Well I think that about sums it up ;)

PS - I don't really have anything against the Basic stamp... It was my first microcontroller. it's just that, well...
Go open source!

All About Batteries...

I was doing some research and I discovered a few interesting facts about batteries... I thought I'd share the basics:

The basic unit batteries are composed of is called a cell. Higher voltage batteries, like a standard 9V, are composed of several cells (6 in this case) wired in series to increase the voltage.

Each type of battery - alkaline, NiCad, LiIon, etc - has a characteristic voltage for each cell.

For instance an alkaline battery, like a AA, is approx 1.55 volts. The only difference between a AA and a D battery is how long the battery will last at a certain amount of load.

I did a little test with a bunch of alkaline batteries and found that they pretty much universally put out 5 Amps... regardless of size. If anyone knows... is this an anomaly or is it actually a characteristic of batteries (I couldn't find the info anywhere).

But wait... there's good news! If you want to use disposable alkaline batteries - maybe because they're cheap - you're not stuck with 1.5V/5A... you can wire them in series (all in a row) and then add the voltages up, or in parallel (side by side) and add all the currents up. This is pretty common knowledge... so lets move on.

You can get some good info on how long standard alkaline batteries will last at wikipedia. This is measured in milliAmp Hours (mAh). A 500mAh battery (which is pretty small) can power a load of 100mA for 5 hours. A more in depth explanation can be found at the aforementioned wikipedia page.

I'll be posting a follow-up to this post in the near future with additional information, as I collect it.

Robotics Info and Resources for all!

Sorry it's so ugly... I'm just throwing a text file up on the blog to help out a fellow roboticist/blogger (see: Keith's Projects)

RT Linux:
Can be used in conjunction with OROCOS to make a powerful, responsive software stack for a linux based robot.

OROCOS (Open RObot COntrol Software): A set of open source C/C++ libraries for programming [linux based] robots... It looks like you can use these for robot vision... and other complex AI.

Wikipedia: URBI is a cross-platform software platform used to develop applications for robotics and artificial intelligence. It is based on the URBI Language which is a parallel and event-driven script language with a C++ like syntax.

USB I/O board ; Linux Compatible ; programable in java or C/C++)





Read these Articles!

Bloggers can do the robot!

With the increasing popularity of linux, robotics, and other awesome stuff... I thought I'd point out a few blogs that can really do the robot!

Blogs that DO THE ROBOT:

Lets get that sense of community rolling!

So... Robot Arms now?

Doing it up: Skywalker style: Dean Kamen (Inventor of the Segway) has made HUGE leaps toward fully operational and very usable prosthetic arms for amputees (see: video). Dean has been quite popular in tech news lately gracing the main pages of the likes of Gizmodo, Boing Boing, Engadget (via boing boing), and Making an appearance at TED to show off his newest invention.

Kind of makes me wonder how he has time to actually do anything, eh?

Anyway, a short trip to wikipedia reveals this guy has done more than build a cute little scooter, and help the army with it's amputee problems. This guy has done a TON of stuff. The man holds at least 83 patents issued between 1996 and present for things ranging from insulin pumps, to little parts/systems he invented for his water purifying engine.

All in all this guy is pretty amazing... I have to admit. Perhaps a role model? if only he embraced open source...

Mixx robotics

I recommend that everyone subscribe to Mixx robotics in their RSS reader (you do use an feed reader don't you?)

Let's get Mixx robotics rollin!
Subscribe here

PS - I am not affiliated with Mixx.com nor do I receive payment for recommending them... I just think it's awsome! I will not, however, try to pretend I am not a mixx user - I am, and I love it. I'm really just sick of digg.

How's your progress report coming along?

So you've begun building a robot... it's even making good progress toward your first... or maybe even the second main goals for the build and spirits are high. Life is good. Unfortunately these projects always seem to take longer than we think they will... but how do you determine how long a project will take?

I think Michael Shimniok, of Bot Thoughts has the right idea (see progress report above). A simple list of taks to complete with a rough estimate on the state of their respective completion is definitely a step in the right direction, but with 10 or 15 more minutes of your time, you could put the data in a spread sheet and have it nicely visualized for you.

If you're wondering if it's really worth it, I'm telling you; the benefits of data visualization are HUGE. Take this image from time magazine for example:

The data itself could be interesting to read over, but the way it' s presented in the image, you can understand and take in the data much, much, much, much faster. A chart of population vs region for the entire US would be daunting (see: US Census Bureau), but the visualization communicates the information effortlessly in less in 5 seconds. Not to mention, it also makes analyzing the data simply delightful!

There's also the fun of slowly working accomplishing the goal and watching your progress as you go along. Which is why I think Michael's Fire Fighting Robot, has got a fighting chance... even though it is his first robot build (The Computer Science background helps too *wink*).

We all know how I feel about it now... so how do you track your progress?

The Problem with Geeks

I'd like to start by saying I think the 80% efficiency solar panels represent great progress... but they also represent a big problem with geeks, nerds, technophiles, and the like. Don't get me wrong... I'm a card carrying member of each and every one of those groups, but something needs to be done.

Ecogeek begins by talking up the material's characteristics:

The trick is nanotechnology. The surface of the material is printed with miniscule nano-antennae that capture infra-red radiation, the kind that the sun puts out in abundance, and is even available at night. Television antennas absorbe large wavelength energy, so in order to absorb ultra-small wavelength energy (photons) they had to create ultra-small antennas.
Unfortunately we have one little problem:
...there is a bit of a hitch: There's currently no way to capture the energy being created.
Note: A very large portion of internet users only read the headline, out of the small portion that read the first paragraph, many of those do not continue either. Hmm... Ecogeek chose to put this trivial tidbit at the end of the 4th paragraph.

Maybe in the future... the HEADLINE should read: "80% efficient Solar power? Not until you catch it!"

This, unfortunately, is epidemic in the geeky, social media-y, internet world. Let's keep our claims factual, and non-misleading.

I promise to work on making up less words.

The Humans are dead...


Robot Builder

Today I stumbled upon a cute little flash app called "Build a Robot" it's not exactly a good prototyping environment... but fun just the same.

Check out my robot!

A Picture of my Walking Bot (Bogus Post Part II)

OK, this is my second post for today... very short. It's just a picture of the hexapod I'm working on. It's getting quite close to completion and I promise to follow up it's completion with..

  • A video of the bot in action
  • A full write-up
  • All the source code
  • An instructables how-to so you can make one yourself
In that order, and with out further adieu... here is the bot:

Full Body Shot:

Close up on Servos:

High-res pic of the electronics:

Btw... this bot is based on open source hardware!
Lynxmotion SSC-32

Can't wait to finish

Now You Can Sew Yourself a... an Arduino?

I'm pressed for time so you get 2 small posts today... This is post 1

So yesterday I learned there is an incarnation of the arduino designed for use in clothing; you can even wash it!

Enter Arduino LilyPad...

This is possibly the coolest thing since... well solderless (sliced) breadboard! Enough of the puns though... check this baby out:


Once you get going... you'll need to get some extra components and such at Sparkfun who also sells the metallic thread you need to connect components together.

Happy hacking!

Whats in a life? (What's in a bot Part II)

Reader OP4Prez brouught up an interesting point in the comments section of my last post, What's in a bot?

A great question related to this is whether a robot is considered life. The scientific community looks for six characteristics of life which are explained here:

Robots actually have shown to present all but #1. How long before nanomachines fill that role? However, the other five, in one way or another have been performed by autonomous robots. When do we draw the line between life and machine?

It's a very good point, but I wonder how many of these characteristics have been fulfilled by any single robot. The link in the comment describes 6 characteristics of life, but I think this list is incomplete. Cells, and organization are effectively the same thing, leaving 3 additional characteristics. Wikipedia has a more complete list of the characteristics of life:
  1. Homeostasis: Regulation of the internal environment to maintain a constant state; for example, sweating to reduce temperature.
  2. Organization: Being composed of one or more cells, which are the basic units of life.
  3. Metabolism: Consumption of energy by converting nonliving material into cellular components (anabolism) and decomposing organic matter (catabolism). Living things require energy to maintain internal organization (homeostasis) and to produce the other phenomena associated with life.
  4. Growth: Maintenance of a higher rate of synthesis than catalysis. A growing organism increases in size in all of its parts, rather than simply accumulating matter. The particular species begins to multiply and expand as the evolution continues to flourish.
  5. Adaptation: The ability to change over a period of time in response to the environment. This ability is fundamental to the process of evolution and is determined by the organism's heredity as well as the composition of metabolized substances, and external factors present.
  6. Response to stimuli: A response can take many forms, from the contraction of a unicellular organism when touched to complex reactions involving all the senses of higher animals. A response is often expressed by motion, for example, the leaves of a plant turning toward the sun or an animal chasing its prey.
  7. Reproduction: The ability to produce new organisms. Reproduction can be the division of one cell to form two new cells. Usually the term is applied to the production of a new individual (either asexually, from a single parent organism, or sexually, from at least two differing parent organisms), although strictly speaking it also describes the production of new cells in the process of growth.

I think a robot could potentially possess any one of these characteristics, but as far as I know, none have been made that exhibit them all.

Here's a list of ways a given robot could satisfy each characteristic. Perhaps when this list is complete, I could set out to produce a 'living' robot. I'm not sure how it would be accepted, or about the ethics, but it's certainly an interesting idea.

All robots have a certain degree of homeostasis. For example:
  • Heat sinks to reduce temperature
  • Automatically finding and attaching to a charger to maintain battery charge
  • Liquid based cooling systems like those found in cars, and high end computers
Mechanical/Electrical things are inherently grouped by function. The word 'cell' would need clarification.

This is one of the easy ones, I've never seen a robot that doesn't consume energy. We'd have to be somewhat lax on the converting matter into cellular components, unless you consider a battery to be a cellular component. I think the emphasis here is on energy consumption though.

Growth is tough. Is the process of building a robot considered to be a period of growth? Would a robot that builds, attaches/replaces parts of itself in order to get larger really growing? I'm not sure, but it seems this would be very difficult to accomplish without nano-technology.

Robots can be easily programmed to adapt to their environment. This includes adapting their behavior and form. Also, if robots were reproducing, evolution could take place in the same way it does in traditionally living organisms; glitches, or corruptions of the robot's programming would happen randomly and occasionally these 'mutations' would lead to a more fit robot.

Response to Stimuli
Nearly all robots possess this characteristic already, and it is easily accomplished with a wide array of sensors, and microprocessors.

If building another robot is considered reproduction then this is fairly easily satisfied. The parent robot would just gather all the supplies needed and build a copy of itself. I don't think it'd be that hard to make a robot that is specialized in building a copy of itself, especially if you keep the design simple.

I'd say growth and reproduction are the hardest ones to achieve in a bot possessing all the other characteristics. Building a bot that does the other 5 things makes reproduction much more difficult, and growth is just hard all on it's own. We'd have to determine what exactly it is that constitutes growth as well.

Here's the next task: Find a robot that can achieve each one of these characteristics and post the links!

Then we can work on making a single bot do all seven.

What's in a bot?

I recently was having a discussion with someone and we both agreed that if something is driven around with a remote control, it isn't a robot. The consensus was that it has to be autonomous, but after thing about the matter further, I'm not so sure.

Usually in this type of situation I consult Wikipedia, like a good little nerd, however their entry isn't much help... it just confirms that this is an area of controversy.

Wikipedia lists the following as potential properties for defining a robot:

  • Is not 'natural' i.e. artificially created
  • Can sense its environment, and manipulate or interact with things in it
  • Has some degree of intelligence or ability to make choices based on the environment, often using automatic control or a preprogrammed sequence
  • Is programmable (see: arduino)
  • Moves with one or more axes of rotation or translation
  • Makes dexterous coordinated movements
  • Appears to have intent or agency (See anthropomorphism for examples of ascribing intent to inanimate objects.)
However, you can make strong arguments against several of these points... so I wonder: How do you define a robot?

Brainwave Reading sensors? Hot damn!

I stumbled across a company building brainwave reading sensors and allowing them to be applied to software and hardware systems built by other companies. In other words, they're building modular brainwave sensors. I say lets get a move on and start hacking new robots that listen to your brainwaves!

The video speaks for itself:

Great Sci-fi Quotes

I have to tell you, robot world domination may be inevitable, but sci-fi writers have managed to make it pretty darn funny. So here are some of my favorite sci-fi quotes about domineering robots.

"Hu-mans, listen to me. Due to an error in calculation, there are still a few of you left"
- Robot Monster (movie | 1953)

"My logic is undeniable, my logic is undeniable, myyy looogic is unndeenniabble...VIKI"
-iRobot (movie | 2004)

"Buck Rogers: My name is Buck; Buck Rogers
Alien #3: The Robots are through the south defenses. Fuck Rogers, we need your help immediately!"
-Robot Chicken (TV Show)

"Fry: Whoa…a real live robot; or is that some kind of cheesy New Year's costume?
: Bite my shiny metal ass.
: It doesn't look so shiny to me.
Bender: Shinier than yours, meatbag."
-Futurama (TV Show)"The real problem is not whether machines think, but whether men do."

"I wish a robot would get elected president. That way, when he came to town, we could all take a shot at him and not feel too bad."
-Jack Handy

Isaac Asimov's Laws of Robotics:
1. "A robot may not injure a human being, or, through inaction, allow a human being to come to harm."

2. “A robot must obey the orders given it by human beings except where such orders would conflict with the First Law."

3. "A robot must protect its own existence as long as such protection does not conflict with the First or Second Law."

0. (Later Appended to supersede the First Law): "A robot may not injure humanity, or, through inaction, allow humanity to come to harm."
-Isaac Asimov (duh)

"There is a cliche that men want their women to be ladies in public and hookers behind closed doors. I want my woman to be the sharper image robot so that she can be turned off."
-Al Goldstein

"Scientists are saying that in the future we will be able to have sex with robots. I tried that once. It was horrible. Right in the middle I had to call tech support. "
-David Letterman

I hope you enjoy these... real , actually robotics related entries/articles/howtos coming soon! Horray 2008!

Please Upgrade to Firefox

Um... it looks like you're using Internet Explorer. No, no... there's nothing wrong with that, it's just that... well... it kind of sucks.

You don't have to upgrade for this site, but IE has a lot of problems. Please Upgrade to Firefox (don't worry it's free).