Transcript X001. Intro - Lego NXT, Tetrix, ROBOTC and Motors

LEGO Mindstorms NXT
SOURCES:
Carnegie Mellon
Dacta
Lego
Timothy Friez
Miha Štajdohar
[email protected]
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
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
Ideas
• 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
Programming languages
• NBC, NXC
• NXT Python, .NET
IDE – interactive
development
environment
http://www.teamhassenplug.org/NXT/NXTSoftware.html
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 control
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 IDE
PyODE
PyGame
Python NXT
PyBluez
Method and Approach
• Mapping Program
– Generate movement on NXT robot, record movement
and plot robot’s path in real time in a simulated world.
Moves Robot
Sends
motor
readings
Starts Pygames
Draws readings
on Pygames
• Python + Simulator
– Thread function, lock on global objects
• NXC + Simulator
– Separate program activates robot, simulator polls output values
ROBOTC
•
•
•
•
•
firmware
tasks, program loop
Sensors, 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 enter 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,
#pragma config(Motor, motorB,
PIDControl)
motorLeft, tmotorNormal, PIDControl)
motorRight, tmotorNormal,
//*!!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.
Using Tetrix 12 Volt Motors
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 assuming
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.
First example of Programming
Motors
Programming Your Motors
Enter a blank line or two after the code that was inserted by the Motor and Sensor Setup wizard and
then type in the following:
task main()
{
motor[motorLeft] = 50; // Half power
motor[motorRight] = 50;
}
wait1Msec(1000);
// One second
motor[motorLeft] = 0;
motor[motorRight] = 0;
// Stop