Transcript UFABC

EN1002 Engenharia
Unificada I
Utilizando o LEGO Mindstorms
Centro de Engenharia, Modelagem e Ciências Sociais
Aplicadas
Outline




NXT capabilities
Software development options
Introductory programming projects
Advanced programming projects
Lego Mindstorms NXT
The LEGO Mindstorms® is a robotic building
system consisting of:
•
•
•
•
The NXT Intelligent Brick: the brain of
the system
Sensors and servo motors
LEGO TECHNIC Elements
Programming software
Project Implementation
The system:
PC with USB
Bluetooth adapter,
running control
LabVIEW software
and an NXT sensorequipped robotic
vehicle
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)



NXC (Not eXactly C)



Assembly-like language with libraries
http://bricxcc.sourceforge.net/nbc/
Built upon NBC
Successor to NQC project for RCX
Compatible with standard firmware

http://mindstorms.lego.com/Support/Updat
es/
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_pyth
on/
Similar pros/cons with iCommand
Developing a Remote Control API

Bluetooth library for Java


Opening a Bluetooth connection


http://code.google.com/p/bluecove/
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




Introduce subroutines


Drive with both motors forward for a fixed
time
Drive with one motor to turn
Drive with opposing motors to spin
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


while loops


Must touch the sensor at exactly the right time
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



Limitations of rotation sensors




First project with an effector
Builds upon lessons from previous projects
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”



Robotic forklift


Finds, retrieves, delivers an object
Perimeter security robot



Store path (from line following) in an array
Backtrack when array fills
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:



Left wheel:



Slow = 0
Fast = 100
(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


UP_LEFT, UP_RIGHT


Accelerate motor by one motor state
DOWN_LEFT, DOWN_RIGHT


Both motors unchanged
Decelerate motor by one motor state
Five total actions
Action Selection

Determine whether action is random


If random:


Determined with probability epsilon
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