Lego NXT and LeJOS NXJ - University of Essex

Lego NXT and LeJOS NXJ 

Dongbing Gu 

School of Computer Science and Electronic Engineering 

University of Essex 

UK 

Spring 2013 

D. Gu (Univ. of Essex) Lego NXT and LeJOS NXJ Spring 2013 1 / 37

Outline 

1 Why Lego is different: A History Tour 

2 LEGO Mindstorms NXT: Brick 

3 LEGO Mindstorms NXT: Sensors 

4 LEGO Mindstorms NXT: Motors 

5 LEGO Mindstorms NXT: Communications 

6 Programming Solutions for the LEGO Mindstorms NXT 

7 Writing your first LeJOS NXJ program 

8 LeJOS NXJ Programming Environment 


Why Lego is different 

If you wanted a task to be done by a robot, you first had to build 

your robot, and then you would be able to program it. 

Not easy 

mechanical design and manufacture, 

electronics design and manufacture, 

system integration, 

and then you could program the robot, often in assembly language. 


Why Lego is different 

Now, with Lego, most of the hard bits disappear: you just stick Lego 

bits together to make the robot you want. 

NO mechanical design and manufacture, 

NO electronics design and manufacture, 

NO system integration, 

and you can program the robot in almost any language you want: C, 

Java, Lisp, Ada, Prolog, Logo, and even assembler. 

easy. 


Lego Mindstorms RCX 

At MIT in the 1980s, the Mechanical Engineering Department started 

a course called 2.70: ‘Introduction to Design’. 

An in-house Lego design team, obviously inspired by the MIT work, 

developed the Lego RCX brick. 

Released in 1998 in various kits. 

All kits contain: 

an RCX brick with 3 sensor inputs and 

3 motor outputs, 

2-way IR communication between 

RCX and PC, 

touch, light, rotation, temperature 

sensors, motors, 

Lego parts. 


LEGO Mindstorms NXT: Brick 

Lego Mindstorms NXT was released by Lego in late July 2006 

A new version, Lego Mindstorms NXT 2.0, was announced in January 

2009, featuring an advanced color sensor and other upgraded 

capabilities. 

All kits contain: 

a 32-bit ARM7 microcontroller 

(AT91SAM7S256). 

100 x 64 pixel LCD display. 

4 buttons for user interface. 

Sound channel with 8-bit resolution 

and up to 8 kHz sampling rate. 

wireless Bluetooth and a USB port. 

4 sensor input ports 

3 PWM motor output ports with built 

in encoders (1 degree resolution). 


On Board Memory 

The NXT brick contains 64kB of RAM (Random Access Memory). 

This holds information as long as the battery is connected. 

It contains 256K flash and used for two things: 

The firmware that forms a kind of operating system. It is uploaded to 

the flash memory via the USB driver or Bluetooth link. 

The user programs, compiled on the PC and uploaded via the USB 

driver or Bluetooth link. Note only limited memory is available for 

these! 


Sensor Ports 

Sensors on the NXT can be either analog or digital sensors. 

For analog sensors, one of the sensor input wires contains an analog 

value representing the value of the sensor. 

Digital sensors are more intelligent and typically contain a 

microprocessor. The sensor communicates with the NXT using the 

I2C serial communications protocol. 

Each of the four sensor ports on the NXT can be configured as either 

a digital or analog sensor. 


RGB Color Light Sensors 

The Lego sensor only responds to light 

coming from the front. It is a 

directional sensor. 

The RGB color sensor contains three 

light emitting diodes (LED). 

If there is a reflective object in front of 

the sensor, the sensor will respond to 

the LED light reflected from the object 

The RGB color sensor has a number of 

modes. 


RGB Color Light Sensors 

In red, green or blue reflective modes the sensor only switches on 

that colored LED and then measures the reflected light. 

In ambient mode, all the LEDs are switched off and so the ambient 

light level is measured. 

In full mode, all 3 LEDs are cycled and then a number 1-6 is 

calculated for the nearest color. 

1 Black 

2 Blue 

3 Green 

4 Yellow 

5 Red 

6 White 

It reports color name and light intensity ranging between 1 and 100. 

(In practice you get much less.) 

It outputs colors: red, green, and blue. 


Touch Sensors 

It reports pressed or released. 

It can be used to detect if robot bumps into an obstacle. 


Ultrasonic (Sonar) Sensors 

It produces a ultrasonic pulse wave and listen to the echo. 

It reports distances with a range of about 5cm to 250cm and an 

accuracy of +/ − 3cm. 

It can be used to report distances or detecting obstacles. 

In practice, direction ambiguity is a serious problem. More on this will 

be explained in sensor and noise lecture. 


Compass Sensors 

It measures the earth’s magnetic field and calculates a magnetic 

heading to report direction. 

Calculates to the nearest 1 ◦ and returned as a number from 0 to 359. 

Updates the heading 100 times per second. 

Influenced by local magnetic interference. Objects such as metal 

items, motors, batteries and wires can cause magnetic interference. 

Has a built in calibration function that calculates correction offsets. 


LEGO Mindstorms NXT: Motors 

Lego motors are DC (direct current) serve motors. 

If the terminals are not connected to anything, the motor can spin 

freely. It has a good gearbox, so it can spin for a while. 

If a voltage is applied to the terminals, then current will flow in the 

motor coils. This current will generate a TORQUE that exerts a force 

on the motor that tries to make it rotate. The direction of this force 

depends on the POLARITY of the voltage. 

However, if the motor terminals are simply connected together, the 

motor will no longer spin freely, but will be braked as if a voltage in 

the opposite direction had been applied. 


Motors 

Lego calls power settings ‘Power levels’. They go from 0 to 100. 

For low settings, a slight increase in load can cause a motor to stop. 

Because of the high inertia of the motor, changes in settings take 

some time to have an effect. 

For light loads, the speed does not seem to vary much between power 

settings. 

The curves below shows rotation speed vs. motor power level under 

different loads. 


Motors 

The NXT cable has six wires: white (motor 1), black (motor 2), red 

(ground), green (power), yellow (tacho 1), blue (tacho 2). 

The motor speed is controlled by pulse-width modulation (pwm), 

which works by driving the motor with a variable cycle square wave. 

This effectively turns the motor on and off, fast. The longer it is on, 

the more torque it will generate and the faster it will go. 

The yellow and blue wires are connected to the quadrature encoder. 

They return square wave pulses that are 90 degree out of phase. 

By measuring the frequency of the square wave oscillation, you can 

compute the rotation. 

One cycle corresponds to 2 degree of rotation. 

By tracking both square wave, you can identify quarter cycles, which 

gives you a resolution of 0.5 degree. 


Tachometer 

A tachometer is an instrument that measures the rotation speed of a 

shaft or disk, as in a motor or other machine. 

The NXT motor has a built in tachometer that keeps track of the 

current angle (in degrees) of the motor axle. 

Built-in rotation sensors 360 counts/rotation. 

Rotation sensor provides valued information for motion control and 

navigation. More will be detailed in robot navigation lecture. 


USB, BlueTooth, and Loudspeaker 

The NXT brick contains a full speed USB port (12Mbit/s) and 

BlueTooth wireless communication (Bluetooth Class II V2.0 

compliant). 

They can be used for uploading programs. 

They can also be programmed to communicate with other devices. 

BlueTooth allow you to connect three devices at the same time. 

Loudspeaker with 8 kHz sound quality. 

Sound channel with 8-bit resolution and 8 KHz sample rate. 


Programming Solutions for the LEGO Mindstorms NXT 

Different programming environments are available for LEGO NXT. 

Most of them can be programmed and downloaded onboard: NXT-G, 

ROBOLAB, RobotC, LeJOS. 

There are some which can be used for remote control: iCommand, 

NXT Python. 


NXT-G 

NXT-G is a graphical programming environment developed by 

National Instruments. 

Writing an NXT-G program is very much like creating a flowchart. 

You write a program by dragging icons (‘code blocks’) that describe 

different behaviors, e.g., turn motor A on at 75 percent of full power, 

and connect them with lines to describe the program behavior. 

Using a variety of code blocks, you can control motors, introduce 

delays, play sounds and direct the flow of your code according to the 

state of sensors and timers, etc. 


ROBOLAB 

ROBOLAB was originally developed by Tufts University for LEGO for 

the first generation LEGO Mindstorms RCX microprocessor brick. It 

was extensively enhanced and revised to support both the RCX and 

the second-generation NXT. 

ROBOLAB is another graphical environment, although it is not as 

intuitive as the NXT-G language. 


ROBOTC 

ROBOTC is industry-standard C language, developed by the Robotics 

Academy at Carnegie Mellon University. 

ROBOTC has a similar graphical programming capability, but with it, 

you drag and drop text. 

ROBOTC has a powerful interactive real-time debugger that 

significantly reduces the time it takes to debug programs. 


NXJ 

NXJ is a Java implementation for the NXT. It is standard Java but 

with a much smaller Class library. 

NXJ programs are written and compiled on the PC. The compiled 

programs are then transferred to the NXT where they can be 

executed. 

LeJOS is a tiny (about 16 Kb) Open Source Java-based operating 

system, including a virtual machine for the execution of Java 

bytecode, an API on top of VM, additional software tools. 


LeJOS NXJ 

LeJOS NXJ is a Java programming environment for the LEGO 

MINDSTORMS NXT. It allows you to program LEGO robots in Java. 

It includes all the classes in the NXJ API as well as tools used to 

upload code to the NXT brick. 

As LeJOS is a firmware replacement, it must be flashed onto the 

NXT. 

There are two steps: 

1 javac compiles the source file (.java) into bytecode, creating a file 

(.class). 

2 java runs the bytecode in the file (.class) on the java virtual machine. 


Java Language 

All code in Java is organized in objects. Software objects consist of 

internal state variables and methods (functions) that operate on the 

internal state variables. 

A class is the blueprint from which individual objects are created. This 

means that all Java code is embedded within class data structures. 

You create Java objects in instantiating (making an instance of) a 

Java class. 

A variable in Java can use a class as its data-type. This means that 

once you create an object (i.e. an instance of a Java class) you can 

store that object in a variable that uses the same class as its 

data-type. 


The HelloWorld Program 

A simple Hello World program, a HelloWorld class: 

public class HelloWorld 

{ 

} 

LeJOS requires the standard main method for the program entry 

point: 

public class HelloWorld { 

public static void main (String[] args) { 

} 

} 


LCD Display 

LeJOS NXJ supports the standard java System.out.println method 

and scroll the output on the NXT LCD screen. 



System.out.println(“Hello World”); 

} 

} 

If you run this program as it is, it will display Hello World and then 

immediately return to the menu, so you will not be able to see what is 

displayed. 


Button class 

Button is in the lejos.nxt package. We can either include 

lejos.nxt.Button or lejos.nxt.* to allow any of the standard lejos.nxt 

classes to be used in the program. 

The Button class has a method waitForPress() that waits for any 

button to be pressed. You can find out what methods a class 

supports by looking at the API documentation. 

http://lejos.sourceforge.net/p_technologies/nxt/nxj/api/index.html 

The complete HelloWorld program is: 

import lejos.nxt.*; 



System.out.println(“Hello World”); 

Button.waitForPress(); 

} 

} 


System class 

In Java, the System class provides a set of methods that the user can 

invoke when they want to interact with the Java operating system. By 

default, one object of type System is created for each Java program. 

For example, using some of its methods, you can obtain the current 

time and the settings of various properties associated with the system. 

System also contains three predefined system variables, in, out, and 

err. 

System.in refers to the standard in; by default this is the keyboard; 

System.out refers to the standard output; 

System.err refers to the standard error stream. 


LeJOS NXJ Programming Environment 

Software Packages used in This Course 

Java language: Java SE (Standard Edition) and JRE (Java Runtime 

Environment). 

Java firmware: LeJOS NXJ. 

Java program uploading link: Mindstorms NXT USB driver or 

Bluetooth driver. 

Java IDE: Eclipse IDE. 

The lab computers have already been installed and configured for 

these tools. 

If you want to instal and configure your own computer, see a detailed 

configuration instruction: 

http://www.bartneck.de/2008/03/04/java-lego-nxt-eclipse-tutorial/ 


LeJOS NXJ Main Menu 

When the NXT switch on, it will display the LeJOS logo before 

changing to the main menu. 

After a few second, it will display the main menu. Now it is ready to 

run Java programs. 

If it does not, the LeJOS NXJ firmware should be uploaded into flash 

memory. You can following this link to do so: 

http://www.bartneck.de/2008/03/04/java-lego-nxt-eclipse-tutorial/. 

You need to look at the main menu in order to use it. 

The link to the menu system is: 

http://lejos.sourceforge.net/nxt/nxj/tutorial/MenuSystem/MenuSystem.htm. 


Configure a Eclipse Project 

Starting Eclipse IDE for 

Classic. 

click on 

File→New→Project 

and Select Java Project 

and click next. 

Name it Test. You will 

receive an almost empty 

class. 


Configure Eclipse Project 

Then turn this project into a 

LeJOS project. 

Right-click onto the project 

and select Properties. Select 

Java Build Path on the left. 

Click on the Libraries tab. 

Afterwards, click on Add 

External JARs and locate 

the ‘lib’ directory in 

ProgramFiles\lejos NXJ 

directory. Select classes.jar 

and press Open. The LeJOS 

library will now be listed. 


Java Source File 

Click on 

File→New→Class 

Name it ‘HelloWorld’ 

and check public static 

void main(String[] 

args). 


Java Source File 

You now need to enter a few lines of Java code. In the first line add: 

import lejos.nxt.LCD; 

Next add the following lines to the main method: 

LCD.drawString(Hello World!, 2, 2); 

LCD.refresh(); 

while(true) 

Eclipse is a very smart Java editor that tries to compile your program 

while you write. It will underline errors with a red line. 

Sometimes this automatic compilation does not work and you want to 

force Eclipse to compile. You can achieve this by simply saving the 

file. 


Java Program Uploading 

Now you can save the program and then upload it into the NXT. 

Before you start the uploading procedure you must make sure that 

the NXT is connected to the computer and that the NXT is 

recognized by the operating system. You also need to select your 

main class window in the middle before starting the uploading 

procedure, so that Eclipse knows which class you want to download. 

Notice that the program will run forever. To stop it you need to reset 

the NXT by holding the two middle buttons for a longer time. This 

will then terminate the USB connection, so you need to wait a little 

for it to reconnect before you upload a new program. 


Java Program Improvement 

Of course there are better ways of ending your program, such as 

listening to a button press or after a certain delay. Replace the 

endless while loop with this: 

try { 

Thread.sleep(5000); 

} catch (InterruptedException e) { 

} 

Now you should be able to use Lego NXT with simple codes. More 

detailed programming of Lego NXT will be given in next lecture.

Lego NXT and LeJOS NXJ - University of Essex

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?