using lego mindstorms nxt in the classroom gabriel j. ferrer hendrix college ferrer@hendrix.edu...

Using Lego Mindstorms NXT in the Classroom

Gabriel J. Ferrer

Hendrix College

ferrer@hendrix.edu

http://ozark.hendrix.edu/~ferrer/

Outline

• NXT capabilities

• Software development options

• Introductory programming projects

• Advanced programming projects

Purchasing NXT Kits

• Two options (same price; $250/kit)– Standard commercial kit– Lego Education kit

• http://www.lego.com/eng/education/mindstorms/

• Advantages of education kit– Includes rechargeable battery ($50 value)– Plastic box superior to cardboard– Extra touch sensor (2 total)

• Standard commercial kit– Includes NXT-G visual language

NXT Brick Features

• 64K RAM, 256K Flash

• 32-bit ARM7 microcontroller

• 100 x 64 pixel LCD graphical display

• Sound channel with 8-bit resolution

• Bluetooth radio

• Stores multiple programs– Programs selectable using buttons

Sensors and Motors

• Four sensor ports– Sonar– Sound– Light– Touch

• Three motor ports– Each motor includes rotation counter

Touch Sensors

• Education kit includes two sensors

• Much more robust than old RCX touch sensors

Light Sensor

• Reports light intensity as percentage

• Two modes– Active– Passive

• Practical uses– Identify intensity on paper– Identify lit objects in dark room– Detect shadows

Sound Sensor

• Analogous to light sensor– Reports intensity– Reputed to identify tones

• I haven’t experimented with this

• Practical uses– “Clap” to signal robot

Ultrasonic (Sonar) Sensor

• Reports distances– Range: about 5 cm to 250 cm– In practice:

• Longer distances result in more missed “pings”

• Mostly reliable– Occasionally gets “stuck”– Moving to a new location helps in receiving a

sonar “ping”

Motors

• Configured in terms of percentage of available power

• Built-in rotation sensors– 360 counts/rotation

Software development options

• Onboard programs– RobotC– leJOS– NXC/NBC

• Remote control– iCommand– NXT_Python

RobotC

• Commercially supported– http://www.robotc.net/

• Not entirely free of bugs• Poor static type checking• Nice IDE• Custom firmware• Costly

– $50 single license– $250/12 classroom computers

Example RobotC Program

void forward() { motor[motorA] = 100; motor[motorB] = 100;}

void spin() { motor[motorA] = 100; motor[motorB] = -100;}

Example RobotC Program

task main() {

SensorType[S4] = sensorSONAR;

forward();

while(true) {

if (SensorValue[S4] < 25) spin();

else forward();

}

}

leJOS

• Implementation of JVM for NXT• Reasonably functional

– Threads– Some data structures– Garbage collection added (January 2008)– Eclipse plug-in just released (March 2008)

• Custom firmware• Freely available

– http://lejos.sourceforge.net/

Example leJOS Program

sonar = new UltrasonicSensor(SensorPort.S4);Motor.A.forward();Motor.B.forward();while (true) { if (sonar.getDistance() < 25) { Motor.A.forward(); Motor.B.backward(); } else { Motor.A.forward(); Motor.B.forward(); } }

Event-driven Control in leJOS

• The Behavior interface– boolean takeControl()– void action()– void suppress()

• Arbitrator class– Constructor gets an array of Behavior objects

• takeControl() checked for highest index first

– start() method begins event loop

Event-driven example

class Go implements Behavior { private Ultrasonic sonar = new Ultrasonic(SensorPort.S4);

public boolean takeControl() { return sonar.getDistance() > 25; }

Event-driven example

public void action() { Motor.A.forward(); Motor.B.forward(); }

public void suppress() { Motor.A.stop(); Motor.B.stop(); }}

Event-driven example

class Spin implements Behavior {

private Ultrasonic sonar =

new Ultrasonic(SensorPort.S4);

public boolean takeControl() {

return sonar.getDistance() <= 25;

}

Event-driven example

public void action() { Motor.A.forward(); Motor.B.backward(); }

public void suppress() { Motor.A.stop(); Motor.B.stop(); }}

Event-driven example

public class FindFreespace {

public static void main(String[] a) {

Behavior[] b = new Behavior[]

{new Go(), new Stop()};

Arbitrator arb =

new Arbitrator(b);

arb.start();

}

}

NXC/NBC

• NBC (NXT Byte Codes)– Assembly-like language with libraries– http://bricxcc.sourceforge.net/nbc/

• NXC (Not eXactly C)– Built upon NBC– Successor to NQC project for RCX

• Compatible with standard firmware– http://mindstorms.lego.com/Support/Updates/

iCommand

• Java program runs on host computer• Controls NXT via Bluetooth• Same API as leJOS

– Originally developed as an interim project while leJOS NXT was under development

– http://lejos.sourceforge.net/

• Big problems with latency– Each Bluetooth transmission: 30 ms– Sonar alone requires three transmissions– Decent program: 1-2 Hz

NXT_Python

• Remote control via Python– http://home.comcast.net/~dplau/nxt_python/

• Similar pros/cons with iCommand

Developing a Remote Control API

• Bluetooth library for Java– http://code.google.com/p/bluecove/

• Opening a Bluetooth connection– Typical address: 00:16:53:02:e5:75

• Bluetooth URL– btspp://00165302e575:1; authenticate=false;encrypt=false

Opening the Connection

import javax.microedition.io.*;import java.io.*;

StreamConnection con = (StreamConnection) Connector.open(“btspp:…”);

InputStream is = con.openInputStream();

OutputStream os = con.openOutputStream();

NXT Protocol

• Key files to read from iCommand:– NXTCommand.java– NXTProtocol.java

An Interesting Possibility

• Programmable cell phones with cameras are available

• Camera-equipped cell phone could provide computer vision for the NXT

Introductory programming projects

• Developed for a zero-prerequisite course

• Most students are not CS majors

• 4 hours per week– 2 meeting times– 2 hours each

• Not much work outside of class– Lab reports– Essays

First Project (1)

• Introduce motors– Drive with both motors forward for a fixed time– Drive with one motor to turn– Drive with opposing motors to spin

• Introduce subroutines– Low-level motor commands get tiresome

• Simple tasks– Program a path (using time delays) to drive

through the doorway

First Project (2)

• Introduce the touch sensor– if statements

• Must touch the sensor at exactly the right time– while loops

• Sensor is constantly monitored

• Interesting problem– Students try to put code in the loop body

• e.g. set the motor power on each iteration

– Causes confusion rather than harm

First Project (3)

• Combine infinite loops with conditionals

• Enables programming of alternating behaviors– Front touch sensor hit => go backward– Back touch sensor hit => go forward

Second Project (1)

• Physics of rotational motion

• Introduction of the rotation sensors– Built into the motors

• Balance wheel power– If left counts < right counts

• Increase left wheel power

• Race through obstacle course

Second Project (2)

if (/* Write a condition to put here */) { nxtDisplayTextLine(2, "Drifting left");

} else if (/* Write a condition to put here */) { nxtDisplayTextLine(2, "Drifting right");

} else {

nxtDisplayTextLine(2, "Not drifting");

}

Third Project

• Pen-drawer– First project with an effector– Builds upon lessons from previous projects

• Limitations of rotation sensors– Slippage problematic– Most helpful with a limit switch

• Shapes (Square, Circle)• Word (“LEGO”)

– Arguably excessive

Pen-Drawer Robot

Pen-Drawer Robot

Fourth Project (1)

• Finding objects

• Light sensor– Find a line

• Sonar sensor– Find an object– Find freespace

Fourth Project (2)

• Begin with following a line edge– Robot follows a circular track– Always turns right when track lost– Traversal is one-way

• Alternative strategy– Robot scans both directions when track lost– Each pair of scans increases in size

Fourth Project (3)

• Once scanning works, replace light sensor reading with sonar reading

• Scan when distance is short– Finds freespace

• Scan when distance is long– Follow a moving object

Light Sensor/Sonar Robot

Other Projects

• “Theseus”– Store path (from line following) in an array– Backtrack when array fills

• Robotic forklift– Finds, retrieves, delivers an object

• Perimeter security robot– Implemented using RCX– 2 light sensors, 2 touch sensors

• Wall-following robot– Build a rotating mount for the sonar

Robot Forklift

Gearing the motors

Advanced programming projects

• From a 300-level AI course

• Fuzzy logic

• Reinforcement learning

Fuzzy Logic

• Implement a fuzzy expert system for the robot to perform a task

• Students given code for using fuzzy logic to balance wheel encoder counts

• Students write fuzzy experts that:– Avoid an obstacle while wandering– Maintain a fixed distance from an object

Fuzzy Rules for Balancing Rotation Counts

• Inference rules:– biasRight => leftSlow– biasLeft => rightSlow– biasNone => leftFast– biasNone => rightFast

• Inference is trivial for this case– Fuzzy membership/defuzzification is more

interesting

Fuzzy Membership Functions

• Disparity = leftCount - rightCount• biasLeft is

– 1.0 up to -100– Decreases linearly down to 0.0 at 0

• biasRight is the reverse• biasNone is

– 0.0 up to -50– 1.0 at 0– falls to 0.0 at 50

Defuzzification

• Use representative values:– Slow = 0– Fast = 100

• Left wheel:– (leftSlow * repSlow + leftFast * repFast) /

(leftSlow + leftFast)

• Right wheel is symmetric

• Defuzzified values are motor power levels

Q-Learning

• Discrete sets of states and actions– States form an N-dimensional array

• Unfolded into one dimension in practice

– Individual actions selected on each time step

• Q-values– 2D array (indexed by state and action)– Expected rewards for performing actions

Q-Learning Main Loop

• Select action• Change motor speeds• Inspect sensor values

– Calculate updated state– Calculate reward

• Update Q values• Set “old state” to be the updated state

Calculating the State (Motors)

• For each motor:– 100% power– 93.75% power– 87.5% power

• Six motor states

Calculating the State (Sensors)

• No disparity: STRAIGHT

• Left/Right disparity– 1-5: LEFT_1, RIGHT_1– 6-12: LEFT_2, RIGHT_2– 13+: LEFT_3, RIGHT_3

• Seven total sensor states

• 63 states overall

Action Set for Balancing Rotation Counts

• MAINTAIN– Both motors unchanged

• UP_LEFT, UP_RIGHT– Accelerate motor by one motor state

• DOWN_LEFT, DOWN_RIGHT– Decelerate motor by one motor state

• Five total actions

Action Selection

• Determine whether action is random– Determined with probability epsilon

• If random:– Select uniformly from action set

• If not:– Visit each array entry for the current state– Select action with maximum Q-value from

current state

Q-Learning Main Loop

• Select action• Change motor speeds• Inspect sensor values

– Calculate updated state– Calculate reward

• Update Q values• Set “old state” to be the updated state

Calculating Reward

• No disparity => highest value

• Reward decreases with increasing disparity

Updating Q-values

Q[oldState][action] =

Q[oldState][action] +

learningRate *

(reward + discount * maxQ(currentState) - Q[oldState][action])

Student Exercises

• Assess performance of wheel-balancer

• Experiment with different constants– Learning rate– Discount– Epsilon

• Alternative reward function– Based on change in disparity

Learning to Avoid Obstacles

• Robot equipped with sonar and touch sensor

• Hitting the touch sensor is penalized

• Most successful formulation:– Reward increases with speed– Big penalty for touch sensor

Other classroom possibilities

• Operating systems– Inspect, document, and modify firmware

• Programming languages– Develop interpreters/compilers– NBC an excellent target language

• Supplementary labs for CS1/CS2

Thanks for attending!

• Slides available on-line:– http://ozark.hendrix.edu/~ferrer/presentations/

• Currently writing lab textbook– Introductory and advanced exercises

• ferrer@hendrix.edu