The LEGO MINDSTORMS NXT Idea Book

Book description

This books chapters on programming and design, CAD-style drawings, and abundance of screenshots make it easy for the reader to master the LEGO MINDSTORMS NXT kit and to build and program nine example robots. Chapters cover using the NXT programming language (NXT-G) as well as troubleshooting; design; software; sensors; Bluetooth; even how to create a NXT remote control.

Table of contents

  1. Brief Contents
  2. Contents in Detail (1/2)
  3. Contents in Detail (2/2)
  4. Foreword: Why LEGO Matters
  5. Introduction
    1. The NXT STEP Blog
    2. Who is This Book For?
    3. About this book
    4. How to Use This Book
  6. Part I: Beyond the Basics
    1. Chapter 1: The LEGO MINDSTORMS NXT System
      1. Differences Between the RIS and the NXT
      2. The Electronics
      3. The Building Pieces
      4. The Programming Language
      5. Conclusion
    2. Chapter 2: The Grammar of NXT-G
      1. Is NXT-G a toy programming language?
      2. Where’s the Guidebook?
        1. Help is Built In
        2. Help Index
      3. The Basics: Starting Out
      4. Sequence Beams
      5. Branching and Sequences
      6. Blocks and Structures
        1. Blocks
        2. Cloning Blocks
      7. Loop and Switch Structures
        1. Tabbed View
        2. Keeping Things Neat
          1. Wires
          2. Comment Tool
        3. My Blocks Save Time and Simplify Your Programs
        4. Going With the Flow: Data Dependency
        5. Matching Wires and Plugs
          1. A Deeper Look at Dependency
          2. Solutions Using Variables
          3. Using Data Dependency to Your Advantage
        6. Wiring into a Wait: My Blocks in Action
          1. A Better Way
          2. Cautions
    3. Chapter 3: NXT-G Problems and Solutions
      1. The Dreaded “Mystery” Broken Wire
        1. Remove Bad Wires
      2. Running Out of Memory
        1. Stretching the Memory
        2. Mini Blocks
      3. When to Use a Crowbar in Programming
        1. The Crowbar
        2. A Bigger Crowbar: The Switch
        3. Removing the Crowbar
      4. Variables: The Scoop On Scoping
        1. Local Variables
        2. Global Variables
        3. All Variables Are Global
        4. The Problem with Global Variables
        5. Solving the Problem
      5. The Remarkable Untouchable Variable
      6. An Invitation to Continue
    4. Chapter 4: Debugging—When the Unexpected Occurs
      1. Care to Comment?
      2. Waiting as a Debugging Tool
      3. Listen as You Troubleshoot
      4. Look Before You Leap
      5. Summary
    5. Chapter 5: Making Sense of Sensors
      1. Light Sensor
        1. Block Types
      2. Sound Sensor
        1. Block Types
        2. What the Sound Sensor is Not
      3. Touch Sensor
        1. Block Types
      4. Ultrasonic Sensor
        1. Potential Drawbacks
        2. Accessing the Ultrasonic Sensor
        3. Wait Block
        4. Switch Conditions
      5. Built-In Sensors
      6. Data Plug Reference Chart
    6. Chapter 6: Design
      1. Taking Inventory of Available Resources
        1. Taking Inventory of Smart Parts
        2. Taking Inventory of LEGO Building Parts
        3. Taking Inventory of Chassis Types
      2. Design Concept
        1. Brainstorming Robotic Tasks
        2. Design Feasibility
        3. Hardware Feasibility Check
        4. Software Feasibility Check
      3. Prototyping and Building Techniques
      4. Testing and Improvements
      5. Maintenance and Repairs
      6. The Design Cycle
      7. Worksheets
        1. Smart Parts Worksheet
        2. Smart Part Groups Worksheet
        3. Building Parts and Assemblies Worksheet
        4. Chassis Types Worksheet
        5. Task Worksheet
    7. Chapter 7: Bluetooth on the NXT
      1. Problems With the RCX IR Connection
      2. Bluetooth as Problem Solver
      3. Making a Connection: Wireless Introductions
      4. Time for a Connection
        1. Connecting with a Mac
        2. Connecting with a Windows PC
      5. After Your Device is Paired
      6. Breaking the BT Barrier: Troubleshooting
      7. Networking With Your Peers: NXT-to-NXT Communication
      8. Setting Up an Inter-NXT Connection
        1. Communicating Between NXTs
      9. BT Messaging Under Program Control
        1. Receiving Messages
    8. Chapter 8: NXT-to-NXT Remote Control
      1. Choosing a Robot Platform
      2. Defining a Common Language
      3. Defining a Control System
      4. Programming the Remote Control
      5. Programming Refinements
      6. Mailing Out the Result
      7. The Receiver
        1. Control Issues
      8. Tuning the Program
      9. Where Do We Go From Here?
      10. Giving Control Back to the Robot
        1. Adding Brains to the Vehicle
      11. Future Directions: Going Beyond the Book
  7. Part II: The Robots
    1. Chapter 9: RaSPy: A Rock, Scissors, Paper–Playing Robot
      1. Building RaSPy (1/2)
      2. Building RaSPy (2/2)
      3. Programming RaSPy (1/2)
      4. Programming RaSPy (2/2)
    2. Chapter 10: Beach Buggy Chair: A Ramblin’ Robot
      1. Building the Beach Buggy Chair (1/3)
      2. Building the Beach Buggy Chair (2/3)
      3. Building the Beach Buggy Chair (3/3)
        1. Seat Back
        2. Front Wheel Hub
        3. Front
        4. Robot Back
        5. Final Assembly (Including Sensors
      4. Programming the Beach Buggy Chair (1/2)
      5. Programming the Beach Buggy Chair (2/2)
        1. My Blocks
        2. Putting the Pieces Together
      6. Troubleshooting Tips
      7. Hints for Further Exploration
      8. A Final Thought
    3. Chapter 11: 3D PhotoBot: A 3D Photo Assistant Robot
      1. The Art of Three Dimensional Photography
        1. Producing Three-Dimensional Images
        2. Viewing Your Three-Dimensional Image
      2. Notes on Using Your3D PhotoBot
      3. Building the 3D PhotoBot (1/3)
      4. Building the 3D PhotoBot (2/3)
      5. Building the 3D PhotoBot (3/3)
        1. Subassembly 1
        2. Subassembly 2
        3. Subassembly 3
        4. Main Assembly
      6. Programming the 3D PhotoBot
    4. Chapter 12: CraneBot: A Grabber Robot
      1. Grippers
      2. The Robotic Arm
      3. Building CraneBot (1/5)
      4. Building CraneBot (2/5)
      5. Building CraneBot (3/5)
      6. Building CraneBot (4/5)
      7. Building CraneBot (5/5)
        1. Building the Gripper
        2. Building the Arm
        3. Building the Crane Body
      8. Programming CraneBot
        1. Part 1
        2. Part 2
        3. Part 3
        4. Part 4
    5. Chapter 13: Slot Machine: A One-Armed Robot
      1. What is a Slot Machine?
      2. Hardware Challenges
        1. The Reels
        2. The Lever
        3. The Slot
        4. The Pay-off Mechanism
      3. The Complete Robot
      4. Building the Slot Machine (1/10)
      5. Building the Slot Machine (2/10)
      6. Building the Slot Machine (3/10)
      7. Building the Slot Machine (4/10)
      8. Building the Slot Machine (5/10)
      9. Building the Slot Machine (6/10)
      10. Building the Slot Machine (7/10)
      11. Building the Slot Machine (8/10)
      12. Building the Slot Machine (9/10)
      13. Building the Slot Machine (10/10)
      14. Finishing Up
        1. Adding Symbols
        2. Connecting the Motors and Sensors
      15. General Program Flow
        1. The Game Controller
        2. The Game’s Result Controller
      16. Programming the Slot Machine (1/2)
      17. Programming the Slot Machine (2/2)
        1. The Game Controller
        2. The Game’s Result Controller
      18. Running the Programs
      19. Ideas for Enhancing Your Robot
    6. Chapter 14: BenderBot: An Anti-Theory Music Robot
      1. Building BenderBot (1/2)
      2. Building BenderBot (2/2)
        1. Wiring BenderBot
      3. Programming BenderBot
        1. A Program to Start You Off
        2. Additional Programs to Explore
      4. Learning More
    7. Chapter 15: ScanBot: An Image-Scanning Robot
      1. Building ScanBot (1/4)
      2. Building ScanBot (2/4)
      3. Building ScanBot (3/4)
      4. Building ScanBot (4/4)
        1. NXT Module
        2. Light Sensor Carriage
        3. Final Model
      5. Programming ScanBot (1/5)
      6. Programming ScanBot (2/5)
      7. Programming ScanBot (3/5)
      8. Programming ScanBot (4/5)
      9. Programming ScanBot (5/5)
        1. Defining the Variables
        2. The My Blocks
        3. Increasing the Threshold
        4. Displaying the Updated Threshold
        5. Deciding Whether to Scan the Next Row
      10. Using ScanBot
      11. Trouble-shooting Tips
      12. Above and Beyond
    8. Chapter 16: Marty: A Performance Art Robot
      1. Design Challenges
        1. Holding the Pen
        2. Wheels
      2. Building Marty (1/4)
      3. Building Marty (2/4)
      4. Building Marty (3/4)
      5. Building Marty (4/4)
        1. Left Motor Subassembly
        2. Right Motor Subassembly
        3. The Two-wheeled Chassis
        4. Pen Grip
        5. Left Rail
        6. Right Rail
        7. Pen Housing
        8. Putting It All Together
      6. Programming Marty (1/2)
      7. Programming Marty (2/2)
        1. Marty’s First Drawing
        2. Tweaking the Program
        3. Marty’s Basic My Block Toolkit
      8. Marty Gets Into Shape (1/2)
      9. Marty Gets Into Shape (2/2)
        1. mbPolygon
        2. RandomPolygon
        3. mbStar
        4. RandomStar
        5. mbZigzag
        6. MegaRandom
        7. SpiralStraight
        8. SpiralCurve
      10. Where To Next?
        1. Troubleshooting
  8. Appendix A: Differences Between Sets
  9. Appendix B: Trouble-Free CAD Installation Guide
  10. Index (1/3)
  11. Index (2/3)
  12. Index (3/3)

Product information

  • Title: The LEGO MINDSTORMS NXT Idea Book
  • Author(s): Martijn Boogaarts, Jonathan Daudelin, Brian L. Davis, James Floyd Kelly, Lou Morris, Fay Rhodes, Rick Rhodes, Matthias Paul Scholz, Christopher R. Smith, Rob Torok
  • Release date: September 2007
  • Publisher(s): No Starch Press
  • ISBN: 9781593271503