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