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/laziness-as-an-embedded-engineering-virtue/ http://www.e-techgarage.com/Puck/2009/12/04/laziness-as-an-embedded-engineering-virtue/#comments Fri, 04 Dec 2009 19:11:05 +0000 Puck http://www.e-techgarage.com/Puck/?p=215 After the Rover’s successful motor test, we noticed that assembling the device was a bit finicky.  Rather than fit everything onto the RCM5600W’s prototyping board, it would be easier to layout a printed circuit board.  We could also replace the 8 operational amplifiers with a single 8-pin buffer chip made by Texas Instruments called a 74HCT541.

Jimmy Buffer steps up to the Microphone

We have 8 digital outputs from the Rabbit’s parallel port A that we need to shift from 0-3 volts up to 0-5 volts and we have determined experimentally that we are too lazy to solder 8 Op-Amps.

First, the buffer is a digital device so it will either output 0 volts or 5 volts (Vcc).  According to the buffer chip’s datasheet, it will read anything above 2 volts as a logical 1.  The Rabbit’s output at 3.3 volts will get bumped up to 5 volts by the buffer and that means “bye-bye” to the operational amplifiers.

Swapping out the Op-Amps with an 8-pin buffer

Adding Features

With the circuit already drawn up in DipTrace, it wasn’t tough to update it and add a few new features.

• Add some 50-pin headers so we can plug directly into the RCM5600W’s demonstration board
• Replace the 8 Op-Amps with a single bus driver chip
• Add one more voltage regulator so we have access to 12 volt, 5 volt, and 3.3 volt supplies
• Add a socket for an XBee ZigBee modem

Check out Larry’s blog entry for more details and the files used to create the circuit board.

The New Schematic

Schematic Version 1.1

The last item is a big feature addition.  The Rabbit already has 802.11g Wi-Fi built into the RCM5600W and we’re planning on using the embedded server to deliver web pages for controls and other functionality.  However, Wi-Fi is short range and if we were to hypothetically toss the Rover out of a plane at 30,000 feet his odds of finding a Wi-Fi connection aren’t great as he plummets to the earth.  It might be useful to have a long range wireless connection for commands like “deploy parachute“.

Some of the ZigBee modems like the XBee can have much higher range because they operate at lower frequency.   A high gain ZigBee device operating at 900 Mhz with good line of sight can reach a range of up to 6 miles.  We won’t be sending data quickly, but remote operation becomes a real possibility.

The New Fangled Custom Printed Circuit Board (PCB)

The Rover PCB

The Joy of Lazy

While it might seem like a bad thing to be too lazy to solder down 8 Op-Amps, we have actually reduced the complexity of the design and the overall production cost.  In embedded engineering a simpler design is generally better and a little laziness up front will save us plenty of work later if we decide to build an army of Rovers to conquer the earth.