- The Communications API
- Uploading Map Data
- Controlling the RCX Through a Network
- Controlling the RCX from a Web Page
- RCX Bean
- Alternate Data Transfer Methods
- Alternate Communication Uses
This chapter is from the book
This chapter is from the book
This chapter is from the book
Controlling the RCX from a Web Page
This section describes a very cool way to interact with the RCX brick using a Java Server Page (JSP). In the previous section we accessed the RCX across a network, but the user needed to run the ExplorerCommand class. Now we will create a Web page that allows anyone with a browser to access the RCX. The basic architecture consists of three components: a client Web browser, a Web server, and the RCX brick (Figure 11–10). We will need to create an HTML page for the client browser, JSP code for the server, and leJOS Java for the RCX brick. The JSP is actually HTML code and Java code all in one file, so there are actually only two bodies of code we will write for this project.
){kind=link}
Figure 11-10 Architecture using JSP code and a Web server.
This setup could be useful for running an experiment with groups of people who might want to monitor (or even interact with) the experiment. Imagine a scenario in which a classroom of psychology students is performing an experiment with a lab rat. The behavior of rats is typically conditioned using a Skinner box—a cage containing switches for the rats to push, and food pellets that are dished out to give the animals positive reinforcement. Often the boxes are used to train the animals to perform novel actions, such as play tic-tac-toe or count objects. Using the RCX, it would be very easy for anyone to build a complex Skinner box. A Web cam (or LEGO cam) could even provide a visual presence for viewers. Students could surf to the Web page at any time and look at how the experiment is going, or even interact directly with the animal in the Skinner box. Touch sensors could be used to receive input from the animal, and motors, lights, or sound could be used to interact with the animal. Or, you could turn the tables and have an RCX robot with a neural net run around the Skinner box. There are endless possibilities.
Installing a Web Server
All Web pages are hosted by Web servers, which are just normal computers. The Web server itself must be connected to the IR tower, so you cannot use a third-party Web service to host your Web page. Fortunately there are some free, easy-to-use Web servers available online. Setting up and using the Web server is not going to be a difficult ordeal; in fact, it's about 10 times easier than setting up and using a word processor. You can use any Web server on the market that allows Java Server pages, but in this example we use an excellent server package called Resin by Caucho Technology.
NOTE
This server software is free for noncommercial use only.
Go to the Resin download site at http://www.caucho.com/download.
Download Resin 2.x for the appropriate operating system (Windows or UNIX). The basic Resin package is fine and you do not require Resin-CMP.
Extract the files to an appropriate directory, such as Program Files. There is no installation program.
We are now going to alter the server configuration slightly. Resin serves pages to port 8080 by default, but the standard for HTML pages is port 80. Open the resin.conf file in the conf directory using a text editor.
Scroll down in the file until you see the setting:
<http port='8080'/>
Modify this to:
<http port='80'/>
Now save the file and close it.
That's it! Resin is now installed and ready to go. Run httpd.exe, located in the bin directory (or standalone.exe if you don't want the Java helper window) and the server will start serving Web pages.
To test the server, open your browser and go to the following address: http://localhost (alternately, you can try http://127.0.0.1, or your IP address). A default Web page should come up with Resin information. Any Web pages that are placed in the doc directory will be accessible from your server. Minimize the Resin server window, but leave it running because we will use it for some projects.
NOTE
Now that you have a Web server set up you can convert the previous Explorer project into a Java Applet and include it on a Web page. The applet cannot be hosted by a third-party server because network communications would not be allowed by the Java security model, but as long as the Explorer Server is running at the same IP address as the Web page, it will work fine. First, use the following code for the applet:
import java.applet.Applet;
import java.awt.*;
public class ExplorerApplet extends Applet {
public void init() {
this.add(new ExplorerCommand("209.202.24.208"));
this.resize(400,300);
this.setLayout(new BorderLayout());
}
}
Next, type up the following HTML page:
<html> <head> <title>Explorer Command Center</title> </head> <body> <applet code=ExplorerApplet.class width=500 height=800 > Your browser is not Java-enabled. </applet> </body> </html>
Save this file as explorer.html in the doc directory or Resin. Finally, copy ExplorerApplet.class, ExplorerCommand.class, and ExplorerCommand$ControlListener.class to the doc directory. Run Resin and minimize it, then run ExplorerServer.class to start the RCX server (from its normal directory). Upload RCXExplorer.class to the RCX, place it in front of the IR tower, and press the Run button.
Now browse to the following address and you will see this displayed as an applet: http://localhost/explorer.html.
A Simple Project
Now that the server is up and running we can create an RCX project using the Web. This is just a fun example used to demonstrate the ability to read sensors and control motors. This RCX application simulates the game of Russian Roulette, except instead of spinning the bullet chamber the motor spins an arm in front of a light sensor. If the arm stops in front of the light sensor then the player will lose. For this project, code will need to be running on the RCX brick as well as on a JSP page, which will be executed every time a user interacts with the JSP page. The code on the RCX side contains no concepts that haven't been covered already:
1. import java.io.*;
2. import josx.platform.rcx.comm.*;
3. import josx.platform.rcx.*;
4.
5. public class Roulette implements SensorConstants {
6.
7. private DataOutputStream out;
8. private InputStream in;
9.
10. public Roulette() {
11. RCXDataPort port = new RCXDataPort();
12. out = new DataOutputStream(port.getOutputStream());
13. // No Data Stream needed b/c only byte values read:
14. in = port.getInputStream();
15. Sensor.S1.setTypeAndMode(SENSOR_TYPE_LIGHT, SENSOR_MODE_RAW);
16. Sensor.S1.activate();
17. }
18.
19. public static void main(String args[]) {
20. Roulette roulette = new Roulette();
21. while(true)
22. roulette.play();
23. }
24.
25. /** This method reads a value from the IR tower, rotates
26. * the arm for the specified time, then returns the light
27. * reading to the IR tower. */
28. public void play() {
29. try {
30. int spinTime = in.read();
31.
32. spinArm(spinTime);
33. int sensorValue = sensorValue = Sensor.S1.readValue();
34. LCD.showNumber(sensorValue);
35. out.writeInt(sensorValue);
36. out.flush();
37. } catch (IOException e) {
38. LCD.showNumber(1111);
39. }
40. }
41. /** Spins the arm the desired time. */
42. public static void spinArm(int seconds) {
43. Motor.A.forward();
44. try {
45. Thread.sleep(seconds * 1000);
46. } catch (InterruptedException e) { }
47. Motor.A.stop();
48. try { //Delay to make sure arm is fully stopped:
49. Thread.sleep(100);
50. } catch (InterruptedException e) { }
51. }
52. }
As you can see, this code simply reads a value from the IR port, spins the motor for a period of time, then reads the light sensor value and returns it to the IR port. The JSP portion of the code interacts with the RCX bean, so let's explore this API.