Using the LEGO NXT
March 2007
David Schilling
Gus Jansson
NXT Hardware
Programming Languages
Using the NXT
Demo Robots
NXT – What you see
4 Inputs (digital & analog)
3 Outputs (support for encoders)
Screen (100x64 pixels)
4 Buttons
USB and Bluetooth
Main processor:
Atmel 32-bit ARM processor, AT91SAM7S256
48 MHz
Atmel 8-bit AVR processor, ATmega48
512 Byte RAM
8 MHz
Bluetooth and USB
Bluetooth wireless communication CSR
BlueCoreTM 4 v2.0 +EDR System
Supports the Serial Port Profile (SPP)
Internal 47 KByte RAM
External 8 MBit FLASH
26 MHz
USB 2.0 Full speed com port (12 Mbit/s)
Graphics, Sound, etc
Display 100 x 64 pixel LCD black &
white graphical display
Loudspeaker Sound output channel with
8-bit resolution
Sample rate of 2-16 KHz
4 Buttons
3 output ports 6-wire interface supporting
input from encoders
4 input ports 6-wire interface supporting I2C
as well as analog
1 high speed port, IEC 61158 Type 4/EN 50170
JTag debugging pins if you want them
LEGO has released technical specifications for
all this
Online Documentation - click on
“NXTreme” button for information and
downloads for advanced users
Open source firmware!!!
SDK – Software Developer Kit
HDK – Hardware Developer Kit
BDK – Bluetooth Developer Kit
Biggest improvement over RCX
– rotation counters built in
360 counts per rotation
They are relative, not absolute positions
Maximum speed is approx. 200 RPM
Motors are much stronger than the
other, older LEGO motors
Digital ultrasonic sensor (3cm-100cm)
Light sensor – can control LED
Sound sensor – DB and DBA
Touch sensor - binary
Conversion cable
LEGO has a conversion cable that
allows you to use the sensors and
motors of the RCX on the NXT
And vice versa, but you can’t use the
ultrasonic sensor on the RCX, and the
motors won’t have encoder support
The LEGO NXT wires have odd ends
(like the DEC RJ-12 connector, but
Wiring diagrams:
Analog input
3rd Party Sensors
Prices from $30 to $50 (so far)
HiTechnic (
Packaging like LEGO sensors
Authorized by LEGO
MindSensors (
Circuit boards with connectors
HiTechnic Sensors
Color Sensor
Compass Sensor
Acceleration Sensor
More coming…
Prototype board
Gyro sensor (analog, not I2C digital)
IR Link (to talk to RCX and other LEGO IR devices)
IR Seeker (for robo soccer, for example)
No-contact touch sensor (electrostatic sensor)
Motor Multiplexor
Sensor Multiplexor
MindSensors Sensors
Acceleration Sensor
RCX to NXT communications link
PS2 controller interface
Motor Multiplexor
Magnetic Compass
Pneumatic Pressure Sensor
One way to download programs
Can send files from one NXT to another
Allows up to four NXTs to talk with each
One master, three slaves
Can use a phone as a remote control
for your NXT
Other devices may be supported
Programming Languages
NXT-G code
NXC (and NBC)
Robot C
Java and others
NXT-G code
LEGO’s development environment
Graphical programming
Based on National Instruments’ LabView
Great for quick programs
Wonderful for kids to use
… but a real pain for old geezers like
me who grew up with text
programming languages
NXC (and NBC)
NXC (Not eXactly C) is a language
similar to NQC, which was the most
popular way to program the RCX
Built on NBC, the Next Byte Code
Uses the built in firmware, and p-code
NXC uses BricxCC
Reasonably stable development
Provides support for all LEGO robotic
Robot C
Carnegie Mellon’s programming
language for various robotic platforms
(including VEX, RCX, as well as NXT)
Requires new firmware
Not free (free trial, $30 download)
New firmware, and language
Small portable language for embedded
By Ralph Hemple, the author of pbForth
for the RCX
Compiles on brick!
Use any terminal device to talk to it
Other languages
Java and several other languages are
reportedly in the works as well
MS Robotic Studio also supports the
Download a small client program to NXT
Actual control is on a PC
Programming with NXC
Assuming you are comfortable with C…
How to use the motors
How to read the sensors
Threading model
NXC Programs
NXC is based on C
Restrictions because it’s based on the
built-in P-Code system
There’s no stack
Limited memory
Limited number of tasks (256)
And subroutines, which are also ‘tasks’
NXC program skeleton
#include "NXCDefs.h"
task main()
NXC Sensors
#include "NXCDefs.h"
task main()
SetSensorType( IN_1, SENSOR_TYPE_TOUCH );
SetSensorMode( IN_1, SENSOR_MODE_BOOL );
NXC Sensors
#include "NXCDefs.h"
task main()
SetSensor( IN_1, SENSOR_TOUCH );
NXC Sensors
To read a sensor use
x = Sensor( IN_1 );
NXC Sample program
#include "NXCDefs.h“
task main() {
SetSensor( IN_1, SENSOR_TOUCH );
while( true ) {
if( Sensor( IN_1 ) ) {
PlayToneEx(440, 100, 3, false);
TextOut( 0, LCD_LINE1, "TOUCHING!");
while( Sensor( IN_1 ) )
TextOut( 0, LCD_LINE1, "---------");
while( !Sensor( IN_1 ) )
NXC Motors
Simple motor commands are available
OnFwd(), OnRev(), Off(), Float()
NXC Motors
To use the built-in rotation sensors, you
need to use the new motor commands
Easiest to use is RotateMotor()
RotateMotor( port, speed, angle );
port is OUT_A, OUT_B, OUT_C, or
combinations such as OUT_AB, OUT_ABC
speed is a number -100 to 100
angle is the number of degrees you want
the motor to turn (positive or negative)
Mimicking a Servo Motor
Read the current motor angle
Current = MotorRotationCount( OUT_A );
Calculate how far you need to turn
Delta = Target – Current;
Turn that amount
RotateMotor( OUT_A, speed, Delta );
Displaying Text
The LCD display is useful for
Setting parameters
Runtime messages
… and more
Displaying Text
TextOut( x, y, text );
NumOut( x, y, number );
LCD display
The origin is the bottom left
So TextOut( 0,0, “hi” ) will display in the
bottom left corner
Use the LCD_LINEn macros if you like
to make it easier
Text Example
y = 42;
TextOut(0, LCD_LINE5, "Answer:" );
NumOut( 8*6, LCD_LINE5, y );
// characters are 6 pixels wide
There are also commands to draw lines,
circles, rectangles, and set points
You can display bitmaps from a file
RIC files – contain drawing commands
One problem is there isn’t an easy way
to clear areas of the screen
It’s easy to clear the whole screen
You can display a 1x1 blank bitmap
Tasks and Subroutines
Multiple tasks are possible, but don’t
work like you might expect
Scheduling is different – tasks start
when a ‘dependant’ task finishes
There is no easy way of stopping a task
Use Precedes() or Follows() in a task to
define task dependencies
task FooTask() {
// will start executing when main() finishes
task main() {
// program starts here
Precedes( FooTask );
task BarTask() {
Follows( main );
// will also start executing when main() finishes
Essentially a task that can be called
It suspends the calling task until it
Don’t use task keyword to define these
Can pass in parameters or return a
Subroutine Example
void TestSub( int x, int y, short i )
x = y + i;
task main()
TestSub( 1, 2, 3 );
NXC Help
Preliminary help file is a PDF
There are many samples and a tutorial
Demo Robots
6-legged walker
Crate Dump truck

SMART meeting - Seattle Robotics