|
Sixth example: Feedback control (NxtJLibA autonomous mode)
Purpose: Use the NXT brick as a controller in a feedback control system that keeps the luminosity of a light bulb at a predefined value.
Control theory is an interesting interdisciplinary branch that deals with the behavior of dynamical systems. The desired output of a system is called the reference (Sollwert). The current value from the system measured by a sensor (Istwert) is fed back and compared with the reference. The difference (error value) is fed to the controller that controls the system to keep the error as small as possible. The controller's algorithm determines strongly the time behavior of the system output.
Fig. 1: General case
In our example the system consists of a light bulb attached to a standard light regulator that is rotated by a NXT motor. The motor axe is coupled to the light regulator with a (double) heat shrink tube.
Fig. 2: NXT motor coupled to a standard light regulator
The sensor is a NXT light sensor attached the NXT brick. The NXT reads the light value. If the luminosity is smaller than the reference value, the NXT rotates the regulator so that the light becomes brighter, if the luminosity is greater than the reference value, the NXT rotates the regulator in the reverse direction.
Fig. 3: Light control system using a Lego NXT brick
When using a simple brute force algorithm to control the system, the program becomes straightforward.
// LightRegulator.java
// pos = 0..300
import ch.aplu.nxt.*;
import ch.aplu.util.*;
import lejos.nxt.Button;
public class LightRegulator
{
private final int sollWert = 900;
public LightRegulator()
{
NxtRobot robot = new NxtRobot();
Motor mot = new Motor(MotorPort.A);
robot.addPart(mot);
LightSensor ls = new LightSensor();
robot.addPart(ls);
System.out.println("Initializing...");
init(mot);
int pos = 0;
int istWert;
System.out.println("ESCAPE to quit");
while (!Button.ESCAPE.isPressed())
{
istWert = ls.getValue();
System.out.println("pos " + pos + ",ist " + istWert);
if (istWert > sollWert)
{
pos = pos - 5;
if (pos < 0)
pos = 0;
}
else
{
pos = pos + 5;
if (pos > 300)
pos = 300;
}
mot.continueTo(pos);
}
mot.continueTo(300);
robot.exit();
}
private void init(Motor mot)
{
mot.setSpeed(5);
mot.rotateTo(-300);
mot.resetMotorCount();
}
public static void main(String[] args)
{
new LightRegulator();
}
}
For the sake of a demonstration we use a second NXT to lower the luminosity periodically by moving a colored plastic sheet in front of the light bulb.
Discussion: The control process is not very accurate due to the rough steps. The typical oscillations of the control system are clearly visible.
Seventh
example: Remote data collection (NxtJLibA autonomous mode)
Purpose:
Use the NXT brick as a wireless remote measuring device and
transfer data to a PC via Bluetooth. In this example data is collected
periodically every 100 ms and shown in a simple graph.
For the purpose
of the demonstration the NXT uses a light sensor, but it may be replaced by any other measuring device (temperature sensor, distance sensor, etc). The NXT runs as a Bluetooth
server and waits for a PC client to connect. After the connection is established, the NXT waits in a loop to get a single character from the PC that signals that a new value is requested. The NXT then performs the measurement and sends the value back to the PC.
// BtAcquire.java
// Remote measuring device. Data transfered to a PC client.
// This is a Bluetooth server waiting for a connecting client.
// When the PC client disconnects, the server should wait for the
// next client to connect.
// For a demo, run NxtAcquire.java from ch.aplu.bluetooth distribution
import ch.aplu.bluetooth.*;
import ch.aplu.nxt.*;
import lejos.nxt.Button;
import lejos.nxt.LCD;
import java.io.*;
public class BtAcquire implements BtListener
{
private final boolean isNxtClient = false; // true, if client is a NXT brick
private NxtRobot robot = new NxtRobot();
private LightSensor ls = new LightSensor();
private BluetoothServer bs;
public BtAcquire()
{
robot.addPart(ls);
LCD.drawString("Server started", 0, 0);
LCD.drawString("Waiting...", 0, 1);
LCD.drawString("Press ESCAPE", 0, 5);
bs = new BluetoothServer(this, isNxtClient);
while (!Button.ESCAPE.isPressed()) {}
bs.cancel();
robot.exit();
}
public void notifyConnection(InputStream is, OutputStream os)
{
LCD.drawString("Connection OK", 0, 1);
DataInputStream dis = new DataInputStream(is);
DataOutputStream dos = new DataOutputStream(os);
robot.playTone(600, 100);
Tools.delay(100);
robot.playTone(1000, 100);
while (true)
{
try
{
dis.readInt(); // Wait for request
}
catch (Exception ex)
{
if (!bs.isCanceled())
{
// Client disconnected, wait for next connect
LCD.clear();
LCD.drawString("Disconnected", 0, 0);
LCD.drawString("Waiting", 0, 1);
LCD.drawString("Press ESCAPE", 0, 5);
robot.playTone(1000, 100);
Tools.delay(100);
robot.playTone(600, 100);
}
break; // Quit while loop
}
try
{
int value = ls.getValue();
dos.writeInt(value);
dos.flush();
LCD.drawString("Lux: " + value, 0, 2);
}
catch (IOException ex)
{}
}
}
public static void main(String[] args)
{
new BtAcquire();
}
}
Discussion:
After installing the Bluetooth server the main process stays
in a (not very efficient) loop until the ESCAPE button is hit. All work
is done in the callback method notifyConnection()
that is called when a client connects. Here we enter a data collection
loop where we wait for any single incomming character that triggers the
measuring process. The acquired data is sent back to the client as an
integer value.
The Java program
running an the PC uses a simple graphics window GPanel
from the package ch.aplu.util for convenience. Any other more sophisticated graphics package may be
used. It imports the package ch.aplu.bluetooth (from www.aplu.ch/bluetooth)
that provides the Bluetooth communication facilities.
// NxtAcquire.java
// Get data from remote NXT in autonomous mode
// For a demo, run BtAcquire.java from the NxtJLibA distribution
import java.io.*;
import ch.aplu.bluetooth.*;
import javax.swing.JOptionPane;
import ch.aplu.util.*;
public class NxtAcquire implements ExitListener
{
private final int channel = 1;
private BluetoothClient bc;
private DataInputStream dis;
private DataOutputStream dos;
private GPanel g = new GPanel(0, 10000, 0, 1000);
public NxtAcquire()
{
g.addExitListener(this);
g.title("NXT Remote Data Acquiring");
drawGrid();
String prompt = "Enter NXT Bluetooth Name";
String init = "NXT";
String serverName;
do
{
serverName = JOptionPane.showInputDialog(null, prompt, init);
if (serverName == null)
System.exit(0);
}
while (serverName.trim().length() == 0);
bc = new BluetoothClient(serverName, channel);
g.title("Trying to connect to " + serverName + "...");
if (!bc.connect())
{
g.title("Connection to " + serverName + " failed");
return;
}
g.title("Connection to " + serverName + " established");
BaseTimer.delay(2000);
dis = new DataInputStream(bc.getInputStream());
dos = new DataOutputStream(bc.getOutputStream());
int t = 0; // in ms
HiResAlarmTimer timer = new HiResAlarmTimer(100);
try
{
while (true)
{
while (timer.isRunning()) {} // Wait until period is over
timer.start();
dos.writeInt(0); // Request data
dos.flush();
int value = dis.readInt();
g.title("Time: " + t + " ms Value: " + value);
if (t == 0)
{
drawGrid();
g.move(t, value);
}
else
g.draw(t, value);
t += 100; // Time step
if (t == 10000)
t = 0;
}
}
catch (Exception ex)
{}
g.title("Disconnected. Click [x] to quit");
bc.disconnect();
}
public void notifyExit()
{
if (bc.isConnected())
bc.disconnect();
else
System.exit(0);
}
private void drawGrid()
{
g.clear();
for (int x = 0; x <= 10000; x += 1000)
g.line(x, 0, x, 1000);
for (int y = 0; y <= 1000; y += 100)
g.line(0, y, 10000, y);
}
public static void main(String[] args)
{
new NxtAcquire();
}
}
Discussion: Because
the data should be acquired periodically with a precise period, a simple
loop using a delay() or
sleep() is not appropriate.
We use a HiResAlarmTimer
that runs (backward) in a background thread parallel to the loop code.
When the loop code is accomplished, we wait for the remaining time until the timer
reaches zero.
The acquired data
is shown in a simple graphics windows that provides user defined double
coordinates. We should be careful to terminate the program properly by
calling disconnect(). This
is established by implementing an ExitListener
with notifyExit()
that is called when
the title bar's close button is hit.
When we walked around near a light bulb
with the light sensor attached the the NXT brick, the following time dependency
of the measured luminosity was displayed.
Using the same technique, measurements could be transfered to a mobile phone. NxtAquire.java is easily ported to J2ME using the package ch.aplu.gidlet. Instead of displaying the data, they could be stored in a file for later processing (data logger).
The PC or the mobile phone could also act as a remote logger for debugging information sent from the NXT program.
| 
