You are previewing Professional Microsoft® Robotics Developer Studio.
O'Reilly logo
Professional Microsoft® Robotics Developer Studio

Book Description

Microsoft Robotics Developer Studio (MRDS) offers an exciting new wayto program robots in the Windows environment. With key portions of the MRDS code available in source form, it is readily extensible and offers numerous opportunities for programmers and hobbyists. This comprehensive book illustrates creative ways to use the tools and libraries in MRDS so you can start building innovative new robotics applications.

The book begins with a brief overview of MRDS and then launches into MRDS concepts and takes a look at fundamental code patterns that can be used in MRDS programming. You'll work through examples—all in C#—of common tasks, including an examination of the physics features of the MRDS simulator. As the chapters progress, so does the level of difficulty and you'll gradually evolve from navigating a simple robot around a simulated course to controlling simulated and actual robotic arms, and finally, to an autonomous robot that runs with an embedded PC or PDA.

What you will learn from this book

  • How to program in the multi-threaded environment provided by the concurrency and coordination runtime

  • Suggestions for starting and stopping services, configuring services, and packaging your services for deployment

  • Techniques for building new services from scratch and then testing them

  • How to build your own simulated environments and robots using the Visual Simulation Environment

  • What robots are supported under MRDS and how to select one for purchase

Who this book is for

This book is for programmers who are interested in becoming proficient in the rapidly growing field of robotics. All examples featured in the book are in C#, which is the preferred language for MRDS.

Table of Contents

  1. Copyright
  2. About the Authors
  3. Credits
  4. Acknowledgments
  5. Foreword
  6. Introduction
    1. Who Is This Book For?
    2. What Is This Book's Focus?
    3. What Does This Book Cover?
      1. Part I: Robotics Developer Studio Fundamentals
      2. Part II: Simulations
      3. Part III: Visual Programming Language (VPL)
      4. Part IV: Robotics Hardware
    4. What You Need to Run the Examples
    5. Conventions
    6. Source Code
    7. Errata
    8. p2p.wrox.com
  7. I. Robotics Developer Studio Fundamentals
    1. 1. Exploring Microsoft Robotics Developer Studio
      1. 1.1. Microsoft Does Robots?
      2. 1.2. Microsoft Robotics Developer Studio Components
        1. 1.2.1. Concurrency and Coordination Runtime (CCR)
        2. 1.2.2. Decentralized Software Services (DSS)
        3. 1.2.3. Visual Simulation Environment
        4. 1.2.4. Visual Programming Language (VPL)
        5. 1.2.5. Robotics Samples
        6. 1.2.6. Packages
          1. 1.2.6.1. The Sumo Package
          2. 1.2.6.2. The Soccer Package
          3. 1.2.6.3. The Courseware Package
      3. 1.3. Support for MRDS
        1. 1.3.1. The SubjuGator
        2. 1.3.2. Prospect 12
        3. 1.3.3. The uBot-5
        4. 1.3.4. KUKA Educational Framework
      4. 1.4. Setting Up Your System
        1. 1.4.1. System Requirements
        2. 1.4.2. Prerequisites
        3. 1.4.3. Installing MRDS 1.5
        4. 1.4.4. Robotics Studio 1.5 Directory Structure
        5. 1.4.5. Installing the Packages
        6. 1.4.6. Installing the Sample Code for This Book
        7. 1.4.7. Verifying the Installation
          1. 1.4.7.1. Runtime
          2. 1.4.7.2. Simulation
          3. 1.4.7.3. ProMRDS Sample Code
      5. 1.5. Additional Resources and Support
        1. 1.5.1. www.Microsoft.com/Robotics
        2. 1.5.2. Tutorials and User Guides
        3. 1.5.3. Online Forums
        4. 1.5.4. Channel 9
      6. 1.6. Summary
    2. 2. Concurrency and Coordination Runtime (CCR)
      1. 2.1. Overview of the MRDS Framework
        1. 2.1.1. The Need for Concurrency
        2. 2.1.2. Services—The Basic Building Blocks
        3. 2.1.3. Orchestration—Putting Services Together
      2. 2.2. Setting Up for This Chapter
        1. 2.2.1. Using the CCRExamples Project
        2. 2.2.2. Entering the Code Manually
        3. 2.2.3. Tips for Coding with MRDS
      3. 2.3. Coordination and Concurrency Runtime
        1. 2.3.1. Concurrent Execution
          1. 2.3.1.1. Tasks
          2. 2.3.1.2. Delegates
          3. 2.3.1.3. Iterators
        2. 2.3.2. Ports and Messages
          1. 2.3.2.1. Reading from a Port
          2. 2.3.2.2. PortSets
        3. 2.3.3. Receivers and Arbiters
          1. 2.3.3.1. Choice
          2. 2.3.3.2. Join
          3. 2.3.3.3. Combining Arbiters
          4. 2.3.3.4. Receiving Multiple Messages
          5. 2.3.3.5. Interleave
        4. 2.3.4. Dispatchers and Dispatcher Queues
      4. 2.4. Implementing Common Control Structures
        1. 2.4.1. Sequential Processing
        2. 2.4.2. Scatter/Gather
        3. 2.4.3. State Machines
        4. 2.4.4. Last Message
        5. 2.4.5. Time Delays
        6. 2.4.6. Periodic Events
        7. 2.4.7. Setting Limits with Timeouts
        8. 2.4.8. Asynchronous I/O
        9. 2.4.9. Blocking I/O
        10. 2.4.10. Throttling
      5. 2.5. Error Handling
        1. 2.5.1. Causalities
        2. 2.5.2. Success/Failure Ports
      6. 2.6. Interoperation with Legacy Code
      7. 2.7. Traps for New Players
      8. 2.8. Summary
    3. 3. Decentralized Software Services (DSS)
      1. 3.1. Overview of DSS
        1. 3.1.1. Contracts
        2. 3.1.2. State
        3. 3.1.3. Behavior
        4. 3.1.4. Execution Context
        5. 3.1.5. DSSP Service Operations
        6. 3.1.6. Generic Contracts
      2. 3.2. Running a DSS Node
        1. 3.2.1. Directory Structure of a DSS Node
        2. 3.2.2. Starting DssHost
        3. 3.2.3. Exploring the DSS Web Pages
          1. 3.2.3.1. The Control Panel
          2. 3.2.3.2. The Service Directory
          3. 3.2.3.3. The Debug and Trace Messages Page
          4. 3.2.3.4. The Contract Directory
          5. 3.2.3.5. The Security Manager Page
          6. 3.2.3.6. Resource Diagnostics
        4. 3.2.4. Running a Robot Service
          1. 3.2.4.1. Manifest Load Results
          2. 3.2.4.2. Viewing Service State
      3. 3.3. Creating a New Service
        1. 3.3.1. Building a Service from Scratch
          1. 3.3.1.1. Using Visual Studio
          2. 3.3.1.2. Using the DssNewService Tool
        2. 3.3.2. Examining the Service Source Files
          1. 3.3.2.1. The Types File
          2. 3.3.2.2. Main Service Implementation File
          3. 3.3.2.3. The Service Manifest
      4. 3.4. Compiling and Running Services
        1. 3.4.1. Compiling a Service
        2. 3.4.2. Setting Up References
        3. 3.4.3. Proxy Assemblies
        4. 3.4.4. Running Services
        5. 3.4.5. Using the Debugger
      5. 3.5. Defining Service State
      6. 3.6. Persisting Service State
        1. 3.6.1. Loading State from a Configuration File
          1. 3.6.1.1. Using Initial State Partner to Load a Configuration File
          2. 3.6.1.2. Specifying a Configuration File in a Manifest
        2. 3.6.2. Saving the State to a Config File
      7. 3.7. Modifying Service State
        1. 3.7.1. Replace
        2. 3.7.2. Update
          1. 3.7.2.1. Defining a Class for an Update Request
          2. 3.7.2.2. Adding a Handler to Process Update Requests
          3. 3.7.2.3. Returning Errors
      8. 3.8. Service Initialization
      9. 3.9. Composing and Coordinating Services
        1. 3.9.1. Starting and Stopping Services Programmatically
          1. 3.9.1.1. Adding a Service Forwarder Port
          2. 3.9.1.2. Main ServiceA Behavior
          3. 3.9.1.3. Using Completion Ports for Synchronization
          4. 3.9.1.4. Dropping Services
          5. 3.9.1.5. Running the Services Together
        2. 3.9.2. Using the Partner Attribute to Start Services
        3. 3.9.3. Modifying Manifests Manually
          1. 3.9.3.1. Use Existing Partner
          2. 3.9.3.2. Contract Identifiers and Case Sensitivity
          3. 3.9.3.3. Use Partner List Entry
      10. 3.10. DSS Tools
        1. 3.10.1. Modifying Manifests Using the DSS Manifest Editor
        2. 3.10.2. DssInfo: Examining Contract Information
        3. 3.10.3. DssProjectMigration: Migrating Services
      11. 3.11. Deploying Services
        1. 3.11.1. Sharing Source Code
        2. 3.11.2. Distributing Executables
        3. 3.11.3. Viewing the Contents of a Package
      12. 3.12. Summary
    4. 4. Advanced Service Concepts
      1. 4.1. Setting Up for This Chapter
        1. 4.1.1. Hardware Setup
        2. 4.1.2. Creating the Service
      2. 4.2. Subscribing and Notifying
        1. 4.2.1. Subscribing to State Changes
        2. 4.2.2. Unsubscribing from State Change Notifications
        3. 4.2.3. Building in Support for Subscriptions and Notifications
      3. 4.3. User Interfaces
        1. 4.3.1. Using Windows Forms
          1. 4.3.1.1. How WinForms Work under MRDS
          2. 4.3.1.2. Creating a WinForm
          3. 4.3.1.3. Passing Information Between a WinForm and a Service
          4. 4.3.1.4. Keyboard Handling
          5. 4.3.1.5. Button Handling
        2. 4.3.2. Using Web Forms
          1. 4.3.2.1. Accessing Services from Web Pages
          2. 4.3.2.2. XSLT Overview
          3. 4.3.2.3. Setting Up Your Development Environment for XSLT
          4. 4.3.2.4. Using XSLT for Enhanced Information Display
          5. 4.3.2.5. Building an XSLT File from Scratch
          6. 4.3.2.6. Creating an XSLT file Using the MRDS Template
          7. 4.3.2.7. Displaying the State Using XSLT
          8. 4.3.2.8. Creating a Web Form for Data Input
          9. 4.3.2.9. Using JavaScript for Client-Side Scripting
      4. 4.4. Using a Camera
        1. 4.4.1. Adding a Camera to a Service
        2. 4.4.2. Setting Up a WinForm for the Video Feed
          1. 4.4.2.1. Handling Connection Requests
          2. 4.4.2.2. Connecting a Webcam
        3. 4.4.3. Processing Video Frames
      5. 4.5. Inheriting from Abstract Services
        1. 4.5.1. Implementing a Generic Service
        2. 4.5.2. Building Virtual Services
      6. 4.6. More on Debugging
        1. 4.6.1. Read the Documentation First
        2. 4.6.2. Use the Visual Studio Debugger
        3. 4.6.3. Examine the State of a Node and Services
        4. 4.6.4. Traditional Debugging Techniques
        5. 4.6.5. Using Trace Level and Logging
      7. 4.7. Where to Go from Here
      8. 4.8. Summary
  8. II. Simulations
    1. 5. The MRDS Visual Simulation Environment
      1. 5.1. The Advantages of Simulation
      2. 5.2. The Difficulties with Simulation
      3. 5.3. Prerequisites
        1. 5.3.1. Hardware Requirements
        2. 5.3.2. Software Requirements
          1. 5.3.2.1. The AGEIA PhysX Engine
          2. 5.3.2.2. Microsoft XNA
          3. 5.3.2.3. Microsoft DirectX
      4. 5.4. Starting the Simulator
      5. 5.5. Using the Simulator
        1. 5.5.1. Navigating the Simulation Environment
        2. 5.5.2. The Status Bar
        3. 5.5.3. The Help Menu
        4. 5.5.4. The Camera Menu
        5. 5.5.5. The Rendering Menu
          1. 5.5.5.1. Visual Rendering Mode
          2. 5.5.5.2. Wireframe Rendering Mode
          3. 5.5.5.3. Physics Rendering Mode
          4. 5.5.5.4. Combined Rendering Mode
          5. 5.5.5.5. No Rendering Mode
        6. 5.5.6. Graphics Settings
        7. 5.5.7. The Physics Menu
        8. 5.5.8. Saving and Loading Scenes
        9. 5.5.9. Saving and Loading Manifests
        10. 5.5.10. Other File Menu Items
      6. 5.6. The Simulation Editor
        1. 5.6.1. Selecting Entities
        2. 5.6.2. Manipulating Selected Entities
        3. 5.6.3. The Entities Menu
          1. 5.6.3.1. Saving and Loading Entities
          2. 5.6.3.2. Creating New Entities
          3. 5.6.3.3. Child Entities
        4. 5.6.4. Modifying Entity State
          1. 5.6.4.1. Graphics Assets
          2. 5.6.4.2. Misc
          3. 5.6.4.3. Physical Properties
        5. 5.6.5. Other Common Entity Properties
      7. 5.7. Built-in Simulation Entities
        1. 5.7.1. Sky and Ground Entities
          1. 5.7.1.1. SkyEntity and SkyDomeEntity
          2. 5.7.1.2. HeightFieldEntity
          3. 5.7.1.3. TerrainEntity
          4. 5.7.1.4. TerrainEntityLOD
        2. 5.7.2. Lights and Shadows
          1. 5.7.2.1. Directional Lights
          2. 5.7.2.2. Omni Lights
          3. 5.7.2.3. Spot Lights
          4. 5.7.2.4. Shadows
        3. 5.7.3. General-Purpose Entities
          1. 5.7.3.1. SingleShapeEntity
          2. 5.7.3.2. MultiShapeEntity
          3. 5.7.3.3. SimplifiedConvexMeshEnvironmentEntity
          4. 5.7.3.4. TriangleMeshEnvironmentEntity
        4. 5.7.4. Robot Entities
          1. 5.7.4.1. Out for a Drive with the iRobot Create
          2. 5.7.4.2. The LEGO NXT Tribot
          3. 5.7.4.3. BumperArrayEntity
          4. 5.7.4.4. DifferentialDriveEntity
          5. 5.7.4.5. Pioneer3DX
          6. 5.7.4.6. LaserRangeFinderEntity
      8. 5.8. Summary
    2. 6. Extending the MRDS Visual Simulation Environment
      1. 6.1. Simulation DLLs and Types
        1. 6.1.1. RoboticsCommon.DLL
        2. 6.1.2. SimulationCommon.DLL
        3. 6.1.3. SimulationEngine.DLL
          1. 6.1.3.1. VisualEntity Methods and Members
          2. 6.1.3.2. The SimulationEngine Class
        4. 6.1.4. SimulationEngine.Proxy.DLL
        5. 6.1.5. PhysicsEngine.DLL
        6. 6.1.6. Microsoft.Xna.Framework.DLL
          1. 6.1.6.1. The Microsoft.Xna.Framework Namespace
          2. 6.1.6.2. The Microsoft.Xna.Framework.Graphics Namespace
        7. 6.1.7. Using Statements and DLL References
      2. 6.2. Building Your Own SRS-Robo-Magellan Simulation
        1. 6.2.1. Simulation Services
        2. 6.2.2. Creating a Simulation Service
        3. 6.2.3. Defining a Custom Robot Entity
        4. 6.2.4. The Drive Methods
        5. 6.2.5. The SimulatedQuadDifferentialDrive Service
          1. 6.2.5.1. Simulation Entity Notifications
          2. 6.2.5.2. Testing the SimulatedQuadDifferentialDrive Service
          3. 6.2.5.3. Testing DriveDistance and RotateDegrees
        6. 6.2.6. Tuning the Corobot Entity
          1. 6.2.6.1. Tuning MotorTorqueScaling
          2. 6.2.6.2. Tuning the Tire Friction
          3. 6.2.6.3. Making the Wheels Turn
          4. 6.2.6.4. Adding Encoders
          5. 6.2.6.5. Making It Look Real
          6. 6.2.6.6. Adding the Custom Mesh to the Corobot Entity
        7. 6.2.7. Adding a Camera
          1. 6.2.7.1. Adding the Camera Entity
          2. 6.2.7.2. Adding the SimulatedWebcam Service
        8. 6.2.8. Adding Infrared Distance Sensors
          1. 6.2.8.1. The CorobotIREntity
          2. 6.2.8.2. Adding a SimulatedIR Service
      3. 6.3. Summary
    3. 7. Using Orchestration Services to Build a Simulation Scenario
      1. 7.1. The Robo-Magellan Referee Service
        1. 7.1.1. Customizing the SimulationTutorial1 Service
        2. 7.1.2. Starting a Service from the Browser
        3. 7.1.3. Building the World and Adding Cameras
        4. 7.1.4. Adding a Sky, Sun, and Ground
        5. 7.1.5. Adding Barriers
          1. 7.1.5.1. Running the Service
        6. 7.1.6. Building a Better Traffic Cone
      2. 7.2. The Robo-Magellan Orchestration Service
        1. 7.2.1. Generating the SimMagellan Service
        2. 7.2.2. Creating a Manifest with the Manifest Editor
        3. 7.2.3. Adding a Windows Forms User Interface
        4. 7.2.4. Creating the Form
        5. 7.2.5. Connecting the Service to the Form
      3. 7.3. How to Make a Robot Behave
        1. 7.3.1. Defining Behavior States
        2. 7.3.2. Implementing the Behavior for Each State
        3. 7.3.3. Processing Camera Frames
        4. 7.3.4. The Wander Behavior
        5. 7.3.5. The Approach State
        6. 7.3.6. The Final Approach State
        7. 7.3.7. The Back Away State
        8. 7.3.8. The Finished State
        9. 7.3.9. The Avoid Collision State
      4. 7.4. Using the SimMagellan Service
      5. 7.5. Future Directions
      6. 7.6. Summary
    4. 8. Simulating Articulated Entities
      1. 8.1. The Joint Class
        1. 8.1.1. The Joint Frame
        2. 8.1.2. Joint Properties
          1. 8.1.2.1. JointAngularProperties
          2. 8.1.2.2. JointLimitProperties
          3. 8.1.2.3. JointDriveProperties
          4. 8.1.2.4. JointLinearProperties
          5. 8.1.2.5. EntityJointConnector
          6. 8.1.2.6. JointProperties
        3. 8.1.3. A Joint TestBench
          1. 8.1.3.1. Subclassing Entity Types to Add Custom Joints
          2. 8.1.3.2. Adding Joints to the Test Bench
            1. 8.1.3.2.1. A Joint with One Angular Degree of Freedom
            2. 8.1.3.2.2. A Joint with a Smaller Damping Coefficient
            3. 8.1.3.2.3. A Six Degree of Freedom Joint
            4. 8.1.3.2.4. A Joint with Different Connector Orientations
            5. 8.1.3.2.5. A Joint with Motion Limits
      2. 8.2. Building a Simulated Robotic Arm
        1. 8.2.1. The Physical Model of the Arm Entity
        2. 8.2.2. Running the Arm Service
        3. 8.2.3. Moving the Arm
        4. 8.2.4. A Fly in the Ointment
        5. 8.2.5. Inverse Kinematics
        6. 8.2.6. Using the Arm User Interface
      3. 8.3. Summary
    5. 9. Adventures in Simulation
      1. 9.1. Simulating a Sumo Competition
        1. 9.1.1. SimulatedSumo
        2. 9.1.2. The Simulated Sumo Referee
        3. 9.1.3. Communicating with the Sumo Referee Service
        4. 9.1.4. The Sample Sumo Behavior
        5. 9.1.5. Creating a New Sumo Player
        6. 9.1.6. Where to Go from Here
      2. 9.2. Building a Six-Legged Walker
        1. 9.2.1. The Hexapod Entity
          1. 9.2.1.1. Building the Main Body and Legs
          2. 9.2.1.2. Defining the Joints
          3. 9.2.1.3. Building the Hexapod
          4. 9.2.1.4. Creating and Attaching the Joints
          5. 9.2.1.5. Attaching a Camera
        2. 9.2.2. The Hexapod Differential Drive Service
          1. 9.2.2.1. The MoveLeg Method
          2. 9.2.2.2. The MoveLegs2 Method
        3. 9.2.3. Where to Go from Here
      3. 9.3. Implementing a Soccer Strategy
        1. 9.3.1. The MRDS Simulated Soccer Environment
        2. 9.3.2. Changing the Players on the Field
        3. 9.3.3. Building a Better Soccer Player
          1. 9.3.3.1. Improved Image Processing
          2. 9.3.3.2. Improved Behavior
        4. 9.3.4. Where to Go from Here
      4. 9.4. Exploring Virtual Worlds
        1. 9.4.1. Background
        2. 9.4.2. The Modified DifferentialDrive Service
        3. 9.4.3. The Maze Simulator
        4. 9.4.4. The ExplorerSim Application
        5. 9.4.5. Where to Go from Here
      5. 9.5. Summary
  9. III. Visual Programming Language
    1. 10. Microsoft Visual Programming Language Basics
      1. 10.1. What Is a Data Flow Language?
      2. 10.2. The VPL Development Environment
      3. 10.3. A Simple VPL Diagram
        1. 10.3.1. Creating a VPL Diagram
        2. 10.3.2. Running a VPL Diagram
      4. 10.4. Inputs, Outputs, and Notifications
      5. 10.5. Basic Activities
      6. 10.6. VPL Variables
      7. 10.7. Looping and Conditionals in VPL
      8. 10.8. The VPL Execution Model
      9. 10.9. Debugging a VPL Diagram
      10. 10.10. Creating Custom Activities
        1. 10.10.1. Defining a ForLoop Custom Activity
        2. 10.10.2. Improving the ForLoop Custom Activity
      11. 10.11. Using Lists and Switch Activities
      12. 10.12. An Example Using List Activities
        1. 10.12.1. The PluralNouns Activity
        2. 10.12.2. The Phrases Activity
        3. 10.12.3. The GetRandom Action
        4. 10.12.4. A Final ForLoop Improvement
      13. 10.13. Summary
    2. 11. Visually Programming Robots
      1. 11.1. VPL Activities and Services
      2. 11.2. Compiling Diagrams to Services
        1. 11.2.1. Service Compilation Options
        2. 11.2.2. A Service Compilation Example
      3. 11.3. Configuring Activities
        1. 11.3.1. Setting the Configuration for a Diagram
        2. 11.3.2. Starting the SimpleDashboard Service Upon Execution
        3. 11.3.3. Modifying the Diagram to Use a Real Robot
      4. 11.4. VPL in the Driver's Seat
      5. 11.5. Using VPL to Read Sensors
      6. 11.6. The Laser Range Finder
      7. 11.7. Controlling Multiple Robots
      8. 11.8. Summary
    3. 12. Visual Programming Examples
      1. 12.1. VPL Explorer
        1. 12.1.1. Interfacing with the Xbox Controller
        2. 12.1.2. Reading the LRF Data
      2. 12.2. VPL Sumo
        1. 12.2.1. The VPL Sumo Main Diagram
        2. 12.2.2. The PlayerOne Start Action
        3. 12.2.3. Reading Data from the Infrared Sensors
        4. 12.2.4. Reading the Create Bumper Sensors
        5. 12.2.5. The Manouver Message
      3. 12.3. Arm Mover
        1. 12.3.1. The ArmMover Activity
        2. 12.3.2. The SetPollInterval Action
        3. 12.3.3. Moving the Arm
      4. 12.4. Line Follower
        1. 12.4.1. The LineMesh Utility
          1. 12.4.1.1. Using the DSS Command-Line Tools
          2. 12.4.1.2. Generating a Mesh from an Image File
        2. 12.4.2. Building a Brightness Sensor
        3. 12.4.3. Building the Simulation Environment
        4. 12.4.4. The Line-Follower VPL Diagram
      5. 12.5. Ball Follower
        1. 12.5.1. Building the Simulation Environment
        2. 12.5.2. The BallFollower VPL Diagram
      6. 12.6. Summary
  10. IV. Robotics Hardware
    1. 13. Using MRDS with Robotics Hardware
      1. 13.1. Safety Considerations Before Starting
      2. 13.2. Types of Robots
        1. 13.2.1. Tethered Robots
          1. 13.2.1.1. The Monitor Program
          2. 13.2.1.2. Boe-Bot Monitor
          3. 13.2.1.3. Boe-Bot Evasive Behavior
          4. 13.2.1.4. The Communications Link
        2. 13.2.2. Autonomous Robots
      3. 13.3. Buying Your First Robot
        1. 13.3.1. General Recommendations
        2. 13.3.2. Robots Discussed in This Book
          1. 13.3.2.1. LEGO Mindstorms NXT
          2. 13.3.2.2. Parallax Boe-Bot
          3. 13.3.2.3. Lynx 6 Robotic Arm
          4. 13.3.2.4. RoboticsConnection Stinger CE
        3. 13.3.3. Other Robots Supported under MRDS
          1. 13.3.3.1. Parallax Scribbler
          2. 13.3.3.2. iRobot Create
          3. 13.3.3.3. Surveyor SRV-1
          4. 13.3.3.4. CoroWare CoroBot
          5. 13.3.3.5. White Box Robotics 914 PC-BOT
          6. 13.3.3.6. MobileRobots Pioneer 3DX
      4. 13.4. Fundamental Concepts: Sensors, Actuators, and Controllers
      5. 13.5. Sensors
        1. 13.5.1. Contact Sensors
        2. 13.5.2. Range Sensors
          1. 13.5.2.1. Infrared Sensors
          2. 13.5.2.2. Sonar Sensors
          3. 13.5.2.3. Laser Range Finders
        3. 13.5.3. Light Sensors
        4. 13.5.4. Video/Image Sensors
        5. 13.5.5. Other Sensors
          1. 13.5.5.1. Global Positioning System Sensors
          2. 13.5.5.2. Compass Sensors
          3. 13.5.5.3. Acceleration/Tilt Sensors
          4. 13.5.5.4. Sound Sensors
          5. 13.5.5.5. Wheel Encoders
      6. 13.6. Actuators
        1. 13.6.1. Motors
        2. 13.6.2. Servo Motors
        3. 13.6.3. Digital Outputs
        4. 13.6.4. Sound and Voice Synthesis
      7. 13.7. Controllers
        1. 13.7.1. Understanding a Closed-Loop Control System
        2. 13.7.2. Behavior-Based Control
      8. 13.8. Summary
    2. 14. Remotely Controlling a Mobile Robot
      1. 14.1. Remote Control and Teleoperation
      2. 14.2. Setting Up Your Robot
        1. 14.2.1. Using a LEGO NXT Tribot with MRDS
          1. 14.2.1.1. Establishing a Bluetooth Connection
          2. 14.2.1.2. Communicating with the LEGO NXT Brick
          3. 14.2.1.3. LEGO NXT V2 Services
        2. 14.2.2. Using a Parallax Boe-Bot with MRDS
          1. 14.2.2.1. Establishing a Bluetooth Connection
          2. 14.2.2.2. Communicating with the Boe-Bot
      3. 14.3. Using the Dashboard
        1. 14.3.1. Creating a Manifest
          1. 14.3.1.1. Setting Up a Manifest
          2. 14.3.1.2. Starting the Simple Dashboard
        2. 14.3.2. Running the Manifest
        3. 14.3.3. Using a Joystick or Gamepad
        4. 14.3.4. Creating a Shortcut to Run Your Robot
      4. 14.4. Making a Robot Dance
        1. 14.4.1. Building a New Service
        2. 14.4.2. Partnering with a Robot Using a Manifest
          1. 14.4.2.1. Using the LEGO NXT Tribot
          2. 14.4.2.2. Using the Boe-Bot
          3. 14.4.2.3. Managing Multiple Manifests
        3. 14.4.3. Reviewing the Results
        4. 14.4.4. Improving the Behavior
        5. 14.4.5. Flashing and Beeping
      5. 14.5. Exploring Using Sensors
        1. 14.5.1. Reading from the Sensors
        2. 14.5.2. Making a LEGO NXT Wander Around
        3. 14.5.3. Making a Boe-Bot Wander Around
          1. 14.5.3.1. Processing Bump Notifications
      6. 14.6. Summary
    3. 15. Using a Robotic Arm
      1. 15.1. Introduction to Articulated Arms
        1. 15.1.1. Servo Basics
        2. 15.1.2. Controlling Joints: Speed and Travel Constraints
          1. 15.1.2.1. Speed
          2. 15.1.2.2. Travel Constraints
        3. 15.1.3. Forward Kinematics
          1. 15.1.3.1. Arm Linkage Configuration
          2. 15.1.3.2. Finally, a Use for Grade-School Geometry
        4. 15.1.4. Inverse Kinematics
      2. 15.2. Setting Up a Lynxmotion L6 Arm
        1. 15.2.1. Building the Lynxmotion L6 Arm
        2. 15.2.2. Starting the Lynxmotion L6 Arm
      3. 15.3. Controlling the L6 Arm
        1. 15.3.1. Using the Generic Arm Contract
          1. 15.3.1.1. Setting Joint Angles
          2. 15.3.1.2. Using GetEndEffectorPose
          3. 15.3.1.3. Using the Dashboard to Control the Arm
        2. 15.3.2. Recording Motions
          1. 15.3.2.1. Using the Simulated Lynx Arm
          2. 15.3.2.2. Inside the Motion Recorder Service
          3. 15.3.2.3. Using the Motion Recorder
      4. 15.4. Pick and Place
        1. 15.4.1. Logjam
        2. 15.4.2. Using an Overhead Camera
      5. 15.5. Summary
    4. 16. Autonomous Robots
      1. 16.1. PC-Based Robots
        1. 16.1.1. Windows XP-Based PCs
        2. 16.1.2. Onboard Laptops
        3. 16.1.3. PDAs
        4. 16.1.4. Embedded PCs
        5. 16.1.5. The Development Environment
      2. 16.2. Setting Up a Stinger Robot
      3. 16.3. Setting Up Your PDA
      4. 16.4. Driving a Stinger Remotely
        1. 16.4.1. Code Overview
          1. 16.4.1.1. Windows Form
          2. 16.4.1.2. Keyboard Handling
          3. 16.4.1.3. Service Operations
          4. 16.4.1.4. Interfacing to the Serializer Board
          5. 16.4.1.5. Reading the Infrared Sensors
      5. 16.5. Wandering Using Sensors
        1. 16.5.1. Handling the IR Sensors
        2. 16.5.2. Defining Wander Modes
        3. 16.5.3. Running the Wander Code
      6. 16.6. Creating a CF Version of the Service
        1. 16.6.1. Deploying a Service to a PDA
          1. 16.6.1.1. Creating a CF Package
          2. 16.6.1.2. Running the Service
        2. 16.6.2. Debugging a Service on a PDA
          1. 16.6.2.1. Testing the PDA Connection
          2. 16.6.2.2. Setting Up for Debugging
      7. 16.7. Setting Up the eBox
        1. 16.7.1. Booting the eBox for the First Time
          1. 16.7.1.1. The Boot Menu
          2. 16.7.1.2. MS-DOS Refresher
        2. 16.7.2. Setting Up the Serial Port
        3. 16.7.3. Setting Up Visual Studio
          1. 16.7.3.1. Software Requirements
          2. 16.7.3.2. Establishing a Connection to eBox
        4. 16.7.4. Transferring Files to the eBox
        5. 16.7.5. Building a Windows CE System Image
      8. 16.8. Running a Service on WinCE
        1. 16.8.1. Setting Up the Service
        2. 16.8.2. Testing Operation of the Service
        3. 16.8.3. Autonomous Operation
      9. 16.9. Where to Go from Here
      10. 16.10. Summary
    5. 17. Writing New Hardware Services
      1. 17.1. Integrating New Hardware
        1. 17.1.1. Microcontrollers
        2. 17.1.2. Chips with Built-in BASIC Interpreters
        3. 17.1.3. MRDS Support from Other Vendors
      2. 17.2. Creating a Generic Brick Service
        1. 17.2.1. Terminology
        2. 17.2.2. Design
          1. 17.2.2.1. No Reconfiguration of the Brick (in this First Version)
          2. 17.2.2.2. All Devices Must Have a Name
          3. 17.2.2.3. Hardware Identifiers
          4. 17.2.2.4. Timestamps
          5. 17.2.2.5. Automatic Connection
          6. 17.2.2.6. Inputs and Outputs
          7. 17.2.2.7. Unit Conversion and Calibration
          8. 17.2.2.8. Locations of Sensors and Actuators
          9. 17.2.2.9. Access to Switches and LEDs is Included as a Convenience
          10. 17.2.2.10. Motors and Wheel Encoders
          11. 17.2.2.11. I2C Bus is Not Supported
        3. 17.2.3. Brick State
          1. 17.2.3.1. Definition of the State
          2. 17.2.3.2. Overview of State Members
          3. 17.2.3.3. Devices
        4. 17.2.4. Device Enums
        5. 17.2.5. Brick Operations
        6. 17.2.6. Additional Components
          1. 17.2.6.1. Creating a Helper DLL
          2. 17.2.6.2. Adding Embedded Resources
      3. 17.3. The Integrator Robot
        1. 17.3.1. Integrator Robot Monitor Program
          1. 17.3.1.1. PICAXE Programming Editor
          2. 17.3.1.2. Pin Assignments
          3. 17.3.1.3. The Main Loop
          4. 17.3.1.4. Protocol Commands
        2. 17.3.2. Creating the Integrator Robot Services
          1. 17.3.2.1. Initialization
          2. 17.3.2.2. Serial Communications
          3. 17.3.2.3. Handling Sensors Using Polling
          4. 17.3.2.4. Completing the Brick Operations
        3. 17.3.3. Creating a New Drive Service
          1. 17.3.3.1. Command Overload!
          2. 17.3.3.2. Timed Operations
          3. 17.3.3.3. Using XSLT
      4. 17.4. Testing a Generic Brick Robot
      5. 17.5. The Hemisson Robot
        1. 17.5.1. Hemisson Brick Service
          1. 17.5.1.1. IR Sensors
          2. 17.5.1.2. Testing the Hemisson Brick
        2. 17.5.2. Hemisson Drive Service
      6. 17.6. Where to Go from Here
      7. 17.7. Summary