Personally, I find this to be a sad state of affairs when an intelligent robot with SONAR vision is asked to behave like an RC car.   I’ve named this mode of operation “Slave Mode” to quietly voice my opinion on the matter.  It’s something like a zombie version of the same rover and you can understand why R2-D2 was so interested in getting rid of that restraining bolt in the first Star Wars movie so he could run for the hills.

For the record, I wrote a command interpreter for the Rover so you can send him into Slave mode with a Wi-Fi device, ZigBee, or even from his own web server.  Truly, he is not going to escape and run off to find Obi-Won Kenobi.

Adding ZigBee to the Rover… Scary Scary!

I admit that ZigBee is pretty intimidating but getting him up and running was less than a day with the Rabbit code.

The first thing you want to realize is that you can set up one of the ZigBee modems to fake out a serial port.  Why is that important?  It means my Rover doesn’t need to know “thing one” about ZigBee.  He just writes or reads with his serial port and the modem does all the work.  If there is no need to worry about the ZigBee software, I don’t increase my project’s code size and my CPU doesn’t have to carry the overhead either.

On the other end I have an RCM4510W acting as the ZigBee coordinator to the Rover’s ZigBee end device.  He comes up using our ZigBee API, sends off a command to set the Rover’s modem as a transparent serial port and then sits there listening as my rover happily chatters away to his fake serial port.  Little does he know that every log entry is being passed wirelessly to my other Rabbit where I can easily dump the data into a log file.

ZigBee at Play

In this video you can see our Rover happily face-planting into a cube wall while he reliably sends us a description of his many woes via the ZigBee connection back to my PC.

You will see an XBee Series 2 modem on the Rover in the video and in the image below.

You can see the blue ZigBee Modem on the PCB.

It’s a Plain-Jane web page but we can always add a style sheet later to beautify it.

One of the reasons why the Rabbit is so compelling as an embedded computer is that with all the different work we are doing with motors and sensor tuning adding an interactive web server is quick and painless.

Here are the preliminary goals:

• Wi-Fi connectivity
• Web Server
• Use Asynchronous JavaScript and XML (AJAX) to display Rover data in real-time

Here is what we need to make this happen:

• A web page
• An XML file
• A C program to run on the rover

The Gratuitous Self-Plug

If you are concerned about the nitty-gritty of how this all works and want to try it yourself, take a look at my Rabbit-Geek’s AJAX Workbook.  It has step-by-step instructions, examples, and code you can use on your own.

Rabbit-Geek Workbook for the Web, RabbitWeb, JavaScript, and AJAX

The rest of the article will be a big picture explanation of how this works.

Easy Wi-Fi

You can configure all the Wi-Fi network settings in the compiler or the code.  In this case, I have configured everything in the compiler like this:

This configuration looks harder than it actually is.   In the TCP_CONFIG.LIB file that comes with the compiler you will find a series of Wi-FI templates for each type of encryption.  I just copied the configuration from the file into this compiler window and then tweaked it for my specific network.

(For the hackers out there, I have foiled your attempts by obscuring my Wi-Fi network password with the Red Rectangle of Redaction. )

Time to Configure Wi-Fi = 5 minutes or less

The Web Server

Assuming for a moment that we have the web page and XML file ready, let’s look at how the Rabbit devices implement a web server.  Fortunately, by adding less than 40 lines of code to our program I can add an interactive web server with AJAX.

Here is the C code:

As you can see it isn’t too scary looking.  After the web server is initialized you just spin in the loop on the http_handler function which is non-blocking and typically returns in about 1 millisecond or less.

Time Creating a C File = Approximately 20 minutes

The Amazing Mutating XML File

The XML file is the easiest piece and while my XML might offend a real web developer, I’m an embedded engineer and it works.

Here is the XML file before it is served:

The only weird looking part of the XML file is the strange “<z? echo ($Rover_Data) ?>“.  When the web server receives a request for the XML file it will strip this RabbitWeb code out and replace it with the value of the Rover_Data string variable from my embedded controller.

For example, if the Rover_Data variable held the string “Scooby Doo” the final served XML file would be updated.

Here is the served XML file when Rover_Data = “Scooby Doo”:

If the web server gets a new request from the file and the Rover_Data string variable has changed, the XML file will also be updated before it is served to the browser.  That’s easy dynamic data for your web page.

Time Creating an XML File = Less than 5 minutes

The HTML page with special AJAX kung-fu

The web page may be a bit intimidating but all it really does is:

1. Use the JavaScript to figure out which browser you are using

2. If your browser supports it, get a copy of the XML file from the server and use it to get the data

3. Put that data on the web page every 500 milliseconds.

Here is the HTML file:

Click to read the code

I just copied this from some of my Workbook samples.

Time Editing the HTML File = About 5 minutes

How Long Did That Take?

Total Time to Add the Web Server = Less than an hour

(It took me longer to write this blog post. 

]]> http://www.e-techgarage.com/Puck/2010/01/13/rover-scholar-explorer-poet-and-web-server/feed/ 1 http://www.e-techgarage.com/Puck/2009/12/04/soccer-robots/ http://www.e-techgarage.com/Puck/2009/12/04/soccer-robots/#comments Fri, 04 Dec 2009 23:37:52 +0000 Puck http://www.e-techgarage.com/Puck/?p=173 I’ve been a fan of robots for some time now and I have a bit of experience with this from college.  Back in the day I was the team leader for Oklahoma State University’s first MiroSot Robot Soccer team.

Puck and the Soccer Robot in 1999

A camera was mounted over the soccer board shown above and the robots were wirelessly controlled by a PC.  One of the fun things possible with robots is using a simple algorithm to create complicated behavior.

To understand the algorithms we used, it would be useful to understand what we had to work with:

• The orange soccer ball would be detected by the camera and we would get X,Y coordinates
• The Soccer Robot would have an X,Y coordinate and a heading telling us which way it was pointing

Algorithm 1 – Mad Ball!

The first algorithm I wrote was very basic.

1. Find the position of the ball and the Robot
2. If the Robot isn’t facing the ball, turn the robot towards the ball
3. Move towards the ball at maximum speed

There wasn’t any consideration of goals or strategy here.  It was just a wild assault on the ball by every robot in sight and it looked a lot like little league soccer with a horde of kids in the center of the field trying to outkick each other.

As simple as this algorithm was, it worked pretty well for making goals.  Granted, sometimes we scored against ourselves, but nobody is perfect.

Algorithm 2 – Goal Fever!

The second algorithm I wrote was an minor adjustment of the first algorithm.

1. Find the position of the ball and the Robot
2. Plot an imaginary kicking line from the center of the enemy goal through the ball
3. Determine if the Robot is on the line with the ball between us an the enemy goal
4. If he isn’t on the line, travel to it by the shortest route possible
5. If he is on the line, turn and strike the ball into the enemy goal

This algorithm was good enough that when we played one-on-one against a robot controlled remotely by a human, we consistently beat them.

What else?

Maybe a Goalie?

If you have the Y coordinate of the ball, it wouldn’t be hard to make a goalie robot that didn’t do anything but try to match the Y position of the ball by moving back and forth in a line.  Executed fast enough, the robot should be able to intercept the ball.

More Sophisticated Robots and Algorithms

We got a working system, but other colleges with experienced legacy teams have gotten into team play with passing and defenders. You will find some pretty intense videos on YouTube showing the traditional 2-wheeled robots as well as humanoid walkers and robots that are at least partially autonomous with their own vision systems.

NaroSot Robot Soccer Teams in Action

The point of this discussion is that with very little code you can produce sophisticated behavioral results.   If your robot’s CPU is fast enough a simple rule or two may be sufficient to produce pretty good behavior.  At the very least you can trash the other lab geeks in a friendly game of soccer.