LEGO Mindstorms NXT

foremanyellowSoftware and s/w Development

Nov 7, 2013 (4 years and 1 day ago)

134 views

LEGO Mindstorms NXT

Carnegie Mellon

Dacta

Lego

Timothy Friez

Miha Štajdohar

miha.stajdohar@fri.uni
-
lj.si

SOURCES:

Principles of Robotics

Integrity
. Robots hold together throughout the competition (no
small task when you are talking about robots built out of
Legos).


Accuracy
. The robot's mechanical outputs and its location
acquisition and feedback to the RCX and subsequent
programming provide the intelligence for precise
performance.


Execution
. The robot performs the tasks it was designed to
accomplish.


Repeatability
. The robot can perform the exact routine time and
time again.


Ergonomics
. The robot is easy to handle, reconfigure, and change
batteries or reprogram if necessary.


Efficiency
. The robot's design makes optimal use of its parts to
execute tasks, minimize friction, and use power.

Why students learn more when they
participate in a real challenge?

Sophisticated robots can be build


Accuracy of mapping
program and NXT


Draw letter “E”


Circle Program


Light Following on
simulation


More videos at
http://www.youtube.com/e
ce191nxt


Examples of mobile
and humanoid
robots


Motivation


Project Overview


Hardware Specification


Lego Robot


Programming
Environments


NXC


RobotC


Method and Approach


Ideas


Design

Mindstorms NXT


mindstorms.lego.com

Mindstorms NXT


mindstorms.lego.com

Ide
as


youtube.com


...

Brick


4
sensor inputs


3 sensor inputs / motor outputs


Programmable

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

From Idea to
Pseudo
-
Code to
software to robot
behavior

Thinking about Programming


Creating a successful robot takes a
team effort
between humans and machines.


Role of the Robot

The robot follows the instructions

it is given, thereby carrying out the

plan.


Human/Machine Communication

1.
Because humans and robots don’t normally speak the same language, a
special language must be used to translate the necessary instructions from
human to robot.


2.
These human
-
to
-
robot languages are called
programming languages
.


3.
Instructions written in them are called
programs.


4.
ROBOTC

is just one of many such programming languages that humans
use to talk to machines.

Think about “Behaviors”

Behaviors are a convenient way to talk about what a robot is doing
and what it must do.

Moving forward, stopping, turning, looking for an obstacle… these
are all behaviors.

Complex Behavior

Some behaviors are big, like
“solve the maze.”


Basic or Simple Behavior

1.
Some behaviors are small, like
“go forward for 3 seconds.”

2.
Big behaviors are actually made
up of these smaller ones.

Planning the Behaviors

The main principle is braking large behaviors into hierarchies of smaller
and smaller behaviors.

You have to understand every piece of input
-
output behavior of a robot

PSEUDOCODE

1.
As the programmer becomes
more experienced, the
organization of the behaviors in
English

will start to include
important techniques from the
programming language itself, like
if
-
else statements and loops
.


2.
This
hybrid language
, halfway
between English and the
programming language, is called
pseudocode
.


3.
It is an important tool in helping
to keep
larger programs
understandable
.


ROBOTC is text based!

1.
Commands to the robot are first written as text on the screen.


2.
They are then processed by the ROBOTC compiler into a machine
language file that the robot can understand.


3.
Finally, they are loaded onto the robot, where they can be run.


Software development options


Onboard programs


RobotC



leJOS


NXC/NBC


Remote control


iCommand


NXT_Python


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

Program
ming languages


NBC, NXC


NXT Python, .NET

http://www.teamhassenplug.org/NXT/NXTSoftware.html

IDE


interactive
development
environment

Programming Environments


NXC


A High
-
level language


Similar to C


Stand
-
alone language (No
plug
-
ins or add
-
ons)


The program runs in the
robot itself.

NXC On Bot

More Robust language

Takes and uses values

Robust language can

Graphically represent

Desired input and results

NXT Python


http://home.comcast.net/~dplau/nxt_python/index.html


demo



bluetooth


remote contro
l

Python IDE












Python Programming Environments


Python 2.4.4


Scripted
Programming
Language


Plug ins


PyGame:
“Simulated World”


PyODE: Shapes,
vectors


PyBluez: Bluetooth
communication


Python NXT: Python
Libraries for NXT


Programs


Light Sensor


Ultrasound Sonar


Sound Sensor

Python NXT

PyBluez

PyODE

PyGame


Mapping Program


Generate movement on NXT robot, record movement
and plot robot’s path in real time in a simulated world.











Python + Simulator


Thread function, lock on global objects


NXC + Simulator


Separate program activates robot, simulator polls output values

Moves Robot

Method and Approach

Sends
motor
readings

Starts Pygames

Draws readings
on Pygames

ROBOT
C



firmware


tasks, program loop


Sen
sors, motors


data


bluetooth, messages


www.robotc.net

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


Bluetooth


PyBluez


http://org.csail.mit.edu/pybluez/



Motors


Configured in terms of percentage of
available power



Built
-
in rotation sensors


360 counts/rotation


No rotation sensors in old Lego

Working with Motors


Selecting Your Hardware Platform

1.
RobotC

supports a variety of different hardware platforms.


2.
For these exercises we will configure
RobotC

to include support for
the
Tetrix
/FTC robots
as well as
pure LEGO robots
.


3.
The “FIRST Tech Challenge (NXT)” platform is a
superset

of the
“NXT” platform.


4.
Whether your robot is using
LEGO motors
or
the
Tetrix

12V motors
,
you can control them with
nearly identical code
.



On the Robot / Platform Type menu make sure that you
have “FIRST Tech Challenge (NXT)” selected.


Click on the
New icon

on the
RobotC toolbar

to start a
new program.


Configuring your Motors


You need to tell RobotC
how your motors are attached

to your NXT.


On the Robot menu, open the
Motors and Sensors Setup

wizard
and select the
FTC Servo/Motor Ctrl tab
.



A. Using LEGO NXT Motors


If your robot is using LEGO NXT motors for the drive wheels, select “No
controllers configured”:


Then go to the Motors tab and fill it in according to
which ports your drive motors are plugged into
.
Make sure to ent
er the names “motorLeft” and “motorRight” correctly so that your robot will go in the
correct direction.


Click OK.

Using pragmas


Two
#pragma

statements and a comment line should have been inserted into
your program looking something like this:



#pragma config(Motor, motorA, motorLeft, tmotorNormal, PIDControl)

#pragma config(Motor, motorB, motorRight, tmotorNormal,
PIDControl)


//*!!Code automatically generated by 'ROBOTC' configuration wizard !!*//



A
#pragma

is an
instruction

to the RobotC compiler to change something
about how your program gets compiled.



The
config()

pragma tells RobotC to automatically include the
necessary
prefix code to configure your program

to use the
motor and sensor ports

you
specified in the wizard.

Important recommendations to
Robot C programmer

1.
You
should not modify

these lines of code by hand.


2.
If the configuration of your robot changes
, go back into the Motor and
Sensor Setup wizard and change the values there.


3.
When you exit the wizard it will update the #pragmas to reflect the changes
you made.


4.
Comment lines in RobotC begin with “//”.


5.
Everything that follows a double
-
slash to the end of the line is ingored by
the compiler.


6.
The comment inserted by the wizard is a reminder that the #pragmas
preceeding it were automatically created for you.


A.

Using Tetrix

12V Motors

If your robot is using the Tetrix

12V motors for its drive wheels
select the configuration that matches
how your robot is wired.
For example, if

you have one motor controller plugged into sensor port 1 and
one servo controller plugged into your

motor controller, you should choose “Standard Configuration.”


Using
Tetrix

12 Volt Motors

Then select the Motors tab, select “Motor equipped (12V)” in the lowest two Type dropdowns. Make
sure to name them “motorRight” and “motorLeft” according to how your robot is wired. Also assu
ming
that your motors are pointing away from each other, make sure to reverse one of them. Don’t worry
about picking the right one to reverse right now. We’ll correct it later if necessary.


Click OK.

Using
Tetrix

12 Volt Motors


Three #pragma statements and a comment line should have been
inserted into your program looking something like this:


#pragma config(Hubs, S1, HTMotor, HTServo, none, none)

#pragma config(Motor, mtr_S1_C1_1, motorRight,
tmotorNormal, PIDControl, reversed)

#pragma config(Motor, mtr_S1_C1_2, motorLeft,
tmotorNormal, PIDControl)

//*!!Code automatically generated by 'ROBOTC' configuration wizard
!!*//


A #pragma is an instruction to the RobotC compiler to change
something about how your program gets compiled.


The config() pragma
tells RobotC to automatically include the
necessary prefix code

to configure your program to use the motor
and sensor ports you specified in the wizard.

Using
Tetrix

12 Volt Motors

1.
You should not modify these lines of code by hand.


2.
If the configuration of your robot changes, go back into
the Motor and Sensor Setup wizard and change the
values there.


3.
When you exit the wizard
it will update the #pragmas

to
reflect the changes you made.

Using
Tetrix

12 Volt Motors

1.
Comment lines in RobotC begin with “//”.


2.
Everything that follows a double
-
slash to the end of the
line is ingored by the compiler.


3.
The comment inserted by the wizard is a reminder that
the #pragmas preceeding it were automatically created
for you.


Using
Tetrix

12 Volt Motors

Programming Your

Motors

Enter a blank line or two after the
code that was inserted by the Motor and Sensor Se
tup wizard and
then type in the following:

task main()

{


motor[motorLeft] = 50; // Half power


motor[motorRight] = 50;


wait1Msec(1000); // One second


motor[motorLeft] = 0; // Stop


motor[motorRight] = 0;

}

First example of Programming
Motors