In this example the challenge is to move the NXT robot whose initial position and orientation is unknown to the controller out of the white area delimited by the black border to the green exit. The robot reports what it "sees" by measuring the luminosity of the light reflected from the ground. It uses a standard Lego light sensor mounted in front of the NXT with its head close to the floor. (It would be nice to transmit a video image in real-time from the NXT over the Bluethooth/TCP channel back to the controller, but this requires a high data bandwidth. But some less greedy information could be returned, e.g. the current position/orientation.)

The controller takes his decision how to move the robot from the reported luminosity and the current orientation and relative position of the NXT. In this simple scenario the position/orientation is not measured and transmitted by the robot, so the controller has only a rough estimation of the position/orientation.

The implementation of the classes NxtController and NxtAgent is rather simple when using the JDroidLib library with its addons for TCP-Communication, Bluetooth and NXT robotics. Because the TCP link should work even on a wide area network where only port 80 is transparent, TCP tunneling is necessary using the concept of TcpJLib (for further information consult http://www.aplu.ch/tcpjlib).

import ch.aplu.android.*;
import ch.aplu.android.nxt.*;
import ch.aplu.tcp.*;
import ch.aplu.util.Monitor;

public class NxtAgent extends GameGrid
  implements NxtConnectionListener, TcpNodeListener
{
  private final String VERSION = "1.0";
  private NxtRover rover;
  private TcpNode node;
  private final String nickname = "NxtAgent";
  private static String sessionID = "777";
  protected GGTextField[] tf = new GGTextField[8];
  private volatile boolean isRunning = true;

  public NxtAgent()
  {
    super(WHITE);
  }

  public void main()
  {
    getBg().clear(BLUE);
    for (int i = 0; i < tf.length; i++)
    {
      tf[i] = new GGTextField(new Location(5, 20 + 20 * i), true);
      tf[i].setFontSize(10);
      tf[i].show();
    }

    tf[0].setText("NxtAgent Version " + VERSION);
    tf[1].setText("Connecting Bluetooth...");

    rover = new NxtRover(this);
    rover.addNxtConnectionListener(this);
    if (rover.connect() != NxtRobot.ConnectState.CONNECTED)
    {
      tf[2].setText("Bluetooth connection failed");
      return;
    }
    tf[2].setText("Bluetooth OK. Connecting TCP...");
    node = new TcpNode();
    node.addTcpNodeListener(this);
    node.connect(sessionID, nickname);
    while (isRunning)
    {
      int value = rover.getIntensity();
      tf[6].setText("Luminosity value = " + value);
      node.sendMessage("" + value);
      delay(100);
    }
    tf[6].setText("Connection to NXT broken");
  }

  public void onPause()
  {
    if (rover != null)
      rover.exit();
    super.onPause();
  }

  public void notifyConnection(boolean connected)
  {
    if (!connected)
      isRunning = false;
  }

  public void nodeStateChanged(TcpNodeState state)
  {
    if (state == TcpNodeState.CONNECTED)
      tf[3].setText("Connected to relay");
    if (state == TcpNodeState.DISCONNECTED)
      tf[3].setText("Disconnected from relay");
  }

  public void statusReceived(String text)
  {
    L.i("statusReceived: " + text);
    if (text.contains("NxtCommander") && !text.contains("Disconnected"))
    {
      announce(1200);
      tf[5].setText("NxtCommander connected");
      Monitor.wakeUp();
    }
    if (text.contains("Disconnected"))
    {
      announce(800);
      tf[5].setText("NxtCommander disconnected");
      rover.stop();   // For security
    }
  }

  private void announce(int freq)
  {
    playTone(freq, 100);
    delay(600);
    playTone(freq, 100);
  }

  public void messageReceived(String sender, String text)
  {
    playTone(1000, 100);
    switch (text.charAt(0))
    {
      case 'S':
        rover.stop();
        break;
      case 'F':
        rover.forward();
        break;
      case 'B':
        rover.backward();
        break;
      case 'L':
        rover.left();
        break;
      case 'R':
        rover.right();
        break;
    }
  }
}

package ch.aplu.nxtagent;

import ch.aplu.android.*;
import ch.aplu.android.nxt.*;

public class NxtRover extends NxtRobot
{
  private NxtAgent gg;
  private Motor motorA = new Motor(MotorPort.A);
  private Motor motorB = new Motor(MotorPort.B);
  private LightSensor ls = new LightSensor();
  private final int linearSpeed = 15;
  private final int angularSpeed = 3; 
  
  public NxtRover(NxtAgent gg)
  {
    super(gg);
    this.gg = gg;
    addPart(motorA);
    addPart(motorB);
    addPart(ls);
  }

  public int getIntensity()
  {
    return ls.getValue();
  }

  public void stop()
  {
    gg.tf[7].setText("Last command: stop");
    motorA.stop();
    motorB.stop();
  }

  public void forward()
  {
    gg.tf[7].setText("Last command: forward");
    motorA.setSpeed(linearSpeed);
    motorB.setSpeed(linearSpeed);
    motorA.forward();
    motorB.forward();
  }

  public void backward()
  {
    ...
  }

  public void left()
  {
    ...
  }

  public void right()
  {
    ...
  }
}

private void selectLuminosity()
{
  GGPreferences prefs = new GGPreferences(this);
  vWhite = prefs.retrieveInt("whiteLevel");
  vBlack = prefs.retrieveInt("blackLevel");
  vGreen = prefs.retrieveInt("greenLevel");

  if (vWhite == null)  // preferences do not exist, set defaults
  {
    vWhite = 600;
    vBlack = 300;
    vGreen = 400;
  }

  vWhite = requestInt("Luminosity Calibration", "White Level", vWhite);
  vBlack = requestInt("Luminosity Calibration", "Black Level", vBlack);
  vGreen = requestInt("Luminosity Calibration", "Green Level", vGreen);

  prefs.storeInt("whiteLevel", vWhite);
  prefs.storeInt("blackLevel", vBlack);
  prefs.storeInt("greenLevel", vGreen);
}