Experiential Robotics Platform (XRP)

What Is the XRP Platform?

The XRP (Experiential Robotics Platform) [beta], developed through a collaboration between WPI and DEKA Research & Development Corp., aims to level the STEM playing field globally and create a future generation of STEM innovators and technology leaders.

The robot kits you received are designed to operate autonomously and perform basic tasks. Its simple, tool-free assembly means robots can be built quickly, and replacement parts can be easily 3-D printed. As part of this platform, WPI will provide virtual support through online courses and will guide students and teachers through the new system, including the ability to scale up using the same hardware with free software updates.

The XRP platform is part of WPI’s global STEM education initiative, which will bring inspiration and possibility to STEM education in ways that make it available to all.

Welcome to Introduction to Robotics

Welcome to the WPI Global STEM Education Initiative Introduction to Robotics course using the new XRP Robots. This course teaches the basics of robotics and programming using two programming languages: Blockly and Python. For new programmers, we recommend that you start with Blockly and switch to Python once you gain more familiarity with programming the robots.

The course has several modules you will work through, starting with an introduction to robotics and later covering driving, sensors, the manipulator (robot arm), and more. Each module contains many interactive challenges using the robot; we recommend that you attempt each one in order to get a better understanding of how to program your XRP. With each module, new programming techniques are introduced to solve concrete robot problems, not as abstract unattached learning. This way, students will see the relevance and need for each concept introduced. The course ends with a challenging final project that brings together everything you have learned in all the previous modules.

_images/deliveryRobotImage.png — Final project delivery robot challenge (see final project module for more information)

The course can be run with one robot per student or with teams of a few students working on each robot. Working in teams allows students to help each other as they work through the course. But one student must not be doing all the work, preventing the other team members from learning the material.

This is a brand-new course with new robots and software, so there may be bugs and unexpected problems. We will strive to be responsive to any questions you might have. If you have any questions or find anything not working as you expect it to, feel free to contact us.

For questions and technical support for the XRP, see our Discourse server. There are instructions on how to sign up in the Getting Help section of this course.

Getting Help

Alongside this ReadTheDocs course, you will be using several online resources for getting your questions answered. The support tools for any technical Q&A will be monitored by the development team and a growing community of users like you. We are using Discourse for online support during this course.

Discourse

The XRP Discourse server provides an easy way to communicate your questions, concerns, ideas, and conversations across the world (within this robotics program). Here you will find a place to posts questions and get answers to issues that you might be having. The staff at WPI will do our best to provide timely answers to your questions, or you might find other more experienced community members jumping in and answering your questions. You will find important resources, links, event information, and office hours here.

Please follow these steps to join the Discourse server:

You will want to create your account, go to https://xrp.discourse.group
You can browse through all the resources on the Discourse server, if you want to post questions and participate, you need to sign up for an account. To do that, click on the Sign Up button in the top right corner of the window and enter your account information.

And you are done! You can now ask any questions you have about the course here or just chat with the other members of the course. We hope you will find this course fun and interesting!

If you want Discourse on your phone, for Android or iPhone there is a Discourse app in the App Store that you can download. When signing up remember to use xrp.discourse.group for the site’s address when asked.

GitHub issues

Another way to contact us, particularly about issues or bugs with any of the software is to create issues in the GitHub repository where the software is developed.

To create a GitHub issue for the course that you are reading now, navigate to the Issues page in the course GitHub repository

To create a GitHub issue for the XRP software libraries, navigate to our GitHub repository’s issue page and select “New issue”.

Describe your problem in detail and click “Submit new issue” to post your issue in the repository. A member of the XRP team will reach out if we have further questions.

Introduction to the XRP: Module Overview

In this module you will:

Learn about the field of robotics
Assemble your robot
Install the software required for programming the robot
Write a short program to familiarize themselves with programming the XRP robot.

At the end of this module, you will be able to:

Recognize the characteristics of robots
Talk about the core disciplines that make up the field of robotics
Understand the components of the robot and how it is assembled
Build familiarity with the tools for programming the XRP

What is a robot

In this course we talk about robots as devices that can:

Sense their environment
Think and perceive what is happening around the robot
Carry out actions using actuators (motors)

There are many ways to define a robot, and this is only one of them. Still, it is a good idea to have a definition of precisely what a robot is. Let’s look at different devices and try to decide whether each of these are robots according to our definitions.

Examples

Radio Controlled Airplane

A radio-controlled airplane is operated by a person who holds a controller and uses the joysticks to control the airplane’s flight path. It requires a remote pilot.

Actuators:

propeller motor
three control surface motors

Sensors: None

Summary: No sensors, no thinking, and it has to be completely controlled by a human.

Not a robot.

Drone

A quadrotor drone is capable of being teleoperated or using autonomous flight. The drone can fly a programmed course, avoid obstacles, return to the landing point, and automatically land.

Actuators:

4 propeller motors
camera aiming motor

Sensors:

GPS (Global Positioning System) receiver
gyros and accelerometers
heading sensor
altitude sensor
rangefinder

The drone senses the environment based on its sensed location and surroundings, and flies on its own from one place to another.

This is a robot.

Vacuum cleaner

A conventional vacuum cleaner is pushed by an operator around the area to clean the floor. Actuators: Motor to turn the fan that sucks up dirt.

Sensors:

Fan speed sensor to ensure consistent performance.

The motor does have a sensor that keeps the motor running at a predetermined speed, but it does not sense the environment or have perception. The operator must supply all the “smarts”.

Not a robot.

Autonomous vacuum cleaner

An autonomous vacuum cleaner can — on its own — start up, vacuum one or more rooms, come back to clean its home base, then continue vacuuming until the whole job is done. It maps out each room in the house for more consistent operation.

Actuators:

Drive motor for the wheels to get around.
Motor for the vacuum for cleaning.
Motor in the base (not shown) that will suck the dirt out of the vacuum cleaner so it can continue cleaning.

Sensors:

Camera for visualizing the room.
Switches on the bumper to allow it to turn around after hitting obstacles.
Rangefinders on the side to measure distance from walls.
Sensor to detect carpet vs floor to change the motor speed.

An autonomous vacuum is fairly smart. It can learn the map of a house after a few runs and efficiently clean rooms. It can avoid obstacles, clean rooms, stop to recharge, and continue where it left off.

This is a robot.

Self-driving car

A self-driving car can be driven conventionally by a human or driven autonomously on city streets and highways on its own.

Actuators:

Wheels for driving.
Motors for controlling turning.
Actuators to allow the robot to break on its own.

Sensors:

8 cameras both outside and inside the car to view the environment and driver’s attentiveness
Rangefinders all around the car to measure the distance to adjacent vehicles
GPS to determine car’s location, and more.

The car is smart and represents state of the art robotics. It can sense the environment, understand where it will be over time, and drive to its destination while safely avoiding obstacles.

This is a robot.

What are the parts of robotics?

Robotics engineering is usually thought of as a combination of three disciplines. They are:

Mechanical engineering - the design and analysis of mechanisms and other mechanical systems.
Electrical engineering - the design of electronic circuits, especially all the sensors.
Computer science - the development of advanced software (computer programs) to interpret at all the sensor data, understand it, and drive the actuators.

Robotics can be thought of as the synergy of these three fields. Designing robots requires a “systems” approach to design. Having knowledge of all three subjects allows one to develop more complex and capable systems than one with only a unitary background.

Robotics is a 3-legged stool. Without any one of these subjects, it falls down.

Building the XRP Robot

Assembling the XRP robot is easy and a complete set of instructions and a video showing the process can be found in the XRP User Guide.

Installing the programming tools

There are two programming languages used throughout this course, Blockly and Python. Both languages are programmed on the XRP robot using XRPCode, an online interactive development tool that can be used for developing programs in either language.

For more information about using XRPCode refer to the XRP User Guide section on XRPCode.

Blockly

This is a drag-and-drop graphical programming system similar to Scratch. Blockly is a good choice for programming the robot, especially for learners with little to no programming experience.

Python

A more widely-used language that scales well for larger programs and works with professional programming tools such as Visual Studio Code and many others. The tool that will be used throughout this course for Python programming is XRPCode, although a more professional tool such as Visual Studio Code can also be used for writing CircuitPython code that is used by the XPR Robot.

Note

One strategy for getting students comfortable with programming more quickly is to start with Blockly getting through basic concepts such as functions, conditionals, loops, and basic robot programming. Once students are familiar with those concepts it is an easy move to Python to complete the course, especially for some more complex challenges, such as the final project. This will allow for quick onboarding without having to learn too many new concepts at the same time. But the decision will depend on the level and experience of the students taking the course.

Robot Driving: Module Overview

In this module students will:

Learn how to make the robot drive at different speeds
Understand the relationship between the wheel speeds and the robot’s motion
Be introduced to motor encoders and how to use them to measure the robot’s movements
Learn about the built in driving functions which help make complicated motions easy

At the end of this module, students will be able to…

Make the robot drive in straight lines, turn corners, and turn in place
Write and use basic functions in the Python programming language
Use different types of loops in Python
Break down a large, repetitive movement sequence into components and then convert into code

Covered Standards (NGSS and CSTA):

3A-AP-16 Design and iteratively develop computational artifacts for practical intent, personal expression, or to address a societal issue by using events to initiate instructions.

3A-AP-17 Decompose problems into smaller components through systematic analysis, using constructs such as procedures, modules, and/or objects.

3B-AP-16 Demonstrate code reuse by creating programming solutions using libraries and APIs.

Understanding Your Robot’s Drivetrain

Introduction

The main body of your XRP is called the drivetrain. We call it this because it holds the two wheels which drive your robot around. Specifically, the XRP has a differential drivetrain. This is the same kind of drivetrain that you would see on a skid-steer loader.

The XRP robot turns using skid-steering which means that while the robot is turning some of the wheels, sometimes the front casters, will be skidding. This requires more energy to complete the turns and depends on the friction of the front casters and the particular driving surface.

Each wheel of your XRP’s drivetrain has a motor attached to it. We can use code to tell this motor what we’d like it to do. Getting the robot to move in a desired path is done by setting the speeds of the two drive motors. There are a lot of variations in how these motors can be set. Here are some basic examples:

Driving straight

The most fundamental common driving that the robot will do is traveling straight. To do this, both wheels move forward at the same speed so that the robot moves straight.

Turning in an arc

Robots can turn in an arc-shaped turn, where one wheel drives faster than the other, causing the robot to turn away from the faster wheel. As the difference in speed between the two wheels increases, the turn tightens. If the turn continues, the robot will drive in a complete circle. In this case, the radius of the circle decreases as the wheel speed differences increase.

Turning in place

One advantage the XRP has over a car steering system is that it can turn in place where the robot turns on a point roughly between the two wheels. This allows the robot to easily get out of tight spaces without having to make a wide arc turn. The point turn is often used for navigating the robot between two places since it follows an easily predictable path.

Turning on one wheel

If one wheel drives forward or backward, and the other wheel remains stopped, the robot will turn in place, with the turning center being the stationary wheel. This is often called a swing turn because the robot swings around the non-moving wheel. With a swing turn, the diameter of the circle traced by the outside wheel is double the wheel track.

Effort

There are several ways we can tell the motors what to do. The most basic thing we can control is the effort the motor should be applying.

Imagine you are riding a bike on a flat surface, pedalling at a normal speed. Now imagine you encounter a hill. If you keep pedalling at the same speed, you won’t slow down when you go up the hill. However, this is not easy! You’d need to pedal harder to go the same speed up the hill.

Now instead imagine that when you get to the hill, you keep pedalling as hard as you were on the flat section. You’ll go up the hill slower, but you won’t be as tired. This is what we mean by the effort of the motor. You’re not telling the motor how fast it should move, but rather how hard it should work. If you tell your robot’s motors to work at a constant effort, your robot’s speed will change depending on whether it is driving on a flat surface or an inclined one.

In both videos, the robot is using the same effort. In the first video, the robot is slowly moving uphill because gravity is fighting against its effort. In the second video, the robot is moving quickly downhill because gravity is working in the same direction as the effort. The force output from the motors is the same, but the speed will depend on resistance to the force.

Tip

Effort is also like the throttle in a car. If you’re going up a hill, you need to push the throttle more to maintain the same speed on the hill. If you don’t push the throttle more, you’ll slow down.

First movements

Note

Elevate your XRP on top of a box or other object so that the wheels aren’t touching anything and can spin freely.

Before driving the robot around, let’s write some simple code to spin one of the wheels. This will help you get familiar with the XRP programming environment and check that your XRP itself is working properly.

Try it out

Create a new file in the IDE called spin_wheels.py. Add the following code to it:

from XRPLib.defaults import *

left_motor.set_effort(0.5)

Run the code and see what happens.

Let’s break down the code line by line:

from XRPLib.defaults import * tells your robot to load code from XRPLib. Don’t worry too much about what all the commands in this line mean right now, just know that you’ll put this line at the top of most of your XRP programs.

left_motor.set_effort(0.5) uses a function provided for you in XRPLib called set_effort that is applied to the left motor. The 0.5 is a parameter to this function which tells it that we’d like the motor to apply 50% effort. On the XRP, we write percentages as decimal numbers between 0 and 1, with 1 being 100%.

Now that we’ve tested the left motor, let’s test the right one! How do you think you would modify the code to spin the right motor? Simply replace left_motor with right_motor.

Try it out

Modify your code and run it on the robot. Make sure the right wheel spins.

Push an object like a pencil against the wheel to add some resistance. Notice how the wheel slows down when you do this, since it would need more effort to keep going the same speed.

Going backwards

We’ve gotten the wheels spinning forwards, but what if we want to go backwards? To do this, we simply have to pass in a negative number for the effort parameter. This means that we can use any number between -1 and 1 for the effort value. -1 will be full effort backwards, 1 will be full effort forwards, and 0 will stop the motor.

Try it out

Try to write code that makes both wheels spin backwards.

This table shows some different effort values and what the wheel would do:

Speed value	Wheel action
1	Wheel spins forwards at 100% effort
0.5	Wheel spins forwards at 50% effort
0	Wheel stops spinning
-0.5	Wheel spins backwards at 50% effort
-1	Wheel spins backwards at 100% effort

Getting the Robot Moving

Basic driving

In the last lesson we learned how to set the effort of each of your robot’s motors individually. Since both of the motors make up the robot’s drivetrain, there’s an easier way to write code to move the robot.

Note

For this lesson, put your XRP on a flat surface like a table or the floor.

Getting your XRP robot to move is simple! Here is some code you can use to drive both the left and right motors at 50% effort:

Python

from XRPLib.defaults import *

drivetrain.set_effort(0.5, 0.5)

Blockly

0.5 and 0.5 are the parameters of the function. The functions you used before only had one parameter, but functions can have as few or as many parameters as you want, or even none at all.

Hint

Parameters are inputs to a function that can dictate attributes like distance or angle to vary its behavior.

Try it out

Add the code to your program to see your robot drive.

Try using different values to make the robot move at different speeds. What happens if you use different values for the left and right wheels?

Afterward, place the robot on a ramp and run it again. Take notice of how the robot moves slower when on the ramp. Why does this happen?

You may notice that your XRP does not drive perfectly straight even though you used the same effort value for both motors. This is because the motors on the XRP aren’t perfect. Every motor is a little bit different. Some of them have more friction inside them than others. In the next module we’ll learn some ways to solve this problem so your robot goes straight every time.

Driving a Distance

Controlling your speed

In addition to setting the effort of the drivetrain’s motors, we can also set their speed. Remember, effort is not the same as speed. We can also ask the XRP’s motors to go a certain speed. When using this function, the XRP will actively measure the speed of the wheels using the motor’s encoder. If the speed falls too low, the motor will automatically increase the effort it applies to speed back up.

Tip

Don’t worry if you’ve never heard of an encoder. We’ll talk more about them later in the lesson.

To set the speed of the drivetrain motors, we use a new function:

Python

from XRPLib.defaults import *

drivetrain.set_speed(5, 5)

Blockly

This tells the drivetrain to set the speed of each drivetrain wheel to travel at 5 centimeters per second. This means if you put the robot down and let both motors drive at this speed, the robot would move 5 centimeters forwards each second.

Try it out

Add the code to your program and run it. Try the same exercise of pushing something up against the wheels of your XRP. Notice how as you add resistance, the motor will increase its effort to keep the speed constant. When you remove the resistance, the effort will go back down.

Since both wheels are now going the same speed, your robot should now also drive straight, unlike when using the set_effort function.

Tip

If you want the robot to go backwards, use a negative speed value just like you did with the effort value.

Driving a distance

We know that we can ask the wheels to spin at a certain speed using a function, but what if we want to make the robot drive a certain distance?

We could ask the robot to move at some speed, and if we know how far it will move each second (for this example we are using a speed of 5 cm/s), we can calculate how many seconds we should drive for to reach that distance.

Let’s use \(d\) to represent the distance we want to drive in cm. But, we want a number in seconds, so we need to convert by the means of dimensional analysis.

To do this, write an expression for the known value with units included:

\[(d \text{ cm})\]

Dimensional analysis involves multiplying this expression by special representations of “1” to convert units. In this case, our speed is 5 cm per second, so we can equate \(5 \text{ cm} = 1 \text{ second}\). Rearranging, we have our special representation of 1:

\[\frac{1 \text{ second}}{5 \text{ cm}} = 1\]

We can now multiply our expression with this special representation of 1:

\[(d \text{ cm}) \cdot \frac{1 \text{ second}}{5 \text{ cm}}\]

Cancelling out units and simplifying, we obtain:

\[(d \cancel{\text{ cm}}) \cdot \frac{1 \text{ second}}{5 \cancel{\text{ cm}}} = \frac{d}{5} \text{ seconds}\]

This resultant expression makes sense! If we want to go 5 cm, we plug in d = 5, and \(\frac{5}{5} = 1\), so we drive for one second. If we want to go 2.5 cm, we plug in d = 2.5, and \(\frac{2.5}{5} = 0.5\), so we drive for half a second.

Keep in mind that this equation is only valid if the robot is moving at 5 cm per second. If you change that speed to be faster or slower, you’ll need to change the denominator of the fraction to that speed to fix the equation.

Try it out

Calculate how many seconds you need to drive for to go one meter if your robot is moving at 5 cm per second. Remember, there are 100 cm in a meter.

To put the above theory into practice, we need to learn about a new function in Python: sleep, which makes the XRP wait for some number of seconds before continuing to the next instruction in the code.

Python

from XRPLib.defaults import *
from time import sleep # We need to import the speed function to use it.

drivetrain.set_speed(5, 5)
sleep(x) # replace x with the time you calculated to go one meter.
drivetrain.stop() # This is another function which makes it easy to stop the robot

Blockly

Tip

The # symbol in Python creates a comment. If you add one to a line of code, anything that comes after it on that line will be ignored by the robot. You can use it to leave notes for yourself, or to quickly disable a line of code while debugging problems.

We use comments in our examples to give you hints about how to write your code. You don’t need to copy our comments into your code, but you should write your own so that you can easily remember what your code does.

Try it out

Add the code to your program and try it out. Remember to replace x with the value you calculated. Try running your robot next to a meter stick to see how accurately your robot drives!

This code you wrote is pretty useful, but what if you wanted to drive other distances?

Let’s say that we want to drive three distances in a row: 25, 50, and 75 cm. How could we program the robot to do this? The easy solution is to copy and paste the code you wrote before three times, and modify it each time:

from XRPLib.defaults import *
from time import sleep

# Drive 25 cm
drivetrain.set_speed(5, 5)
sleep(25 / 5) # Notice how we can write math directly in our program!
drivetrain.stop()

# Drive 50 cm
drivetrain.set_speed(5, 5)
sleep(50 / 5)
drivetrain.stop()

# Drive 75 cm
drivetrain.set_speed(5, 5)
sleep(75 / 5)
drivetrain.stop()

This looks pretty repetitive. Most of this code is exactly the same. In fact, the only change between each block is the parameter we are passing to the sleep function. This is a perfect example of why we have functions. Let’s write our own function to drive the robot a certain distance.

Python

Python uses the keyword def to let you, the programmer, tell it that you would like to define a new function. A full function definition looks like this:

def function_name(parameter1, parameter2, parameter3):
    # put your code here
    # code in your function can use the parameters by name like this:
    print(parameter1 / 5)

In this example function, there are three parameters. Functions can have as many or as few parameters as you want, or even have no parameters at all.

Blockly

In Blockly, you create functions by dragging a block that looks like the picture below. The interface allows you to specify the function name, and pass parameters to the function body. Here, we have a function called some_task (which you should rename based on what your function does) that takes in a parameter called text, and uses prints the text value. Functions can have as many or as few parameters as you want, or even have no parameters at all.

The below blocks calls the function we defined above to run it. The value “Hello” is passed to the text parameter, which results in “Hello” being printed to the console.

Try it out

Define a function called drive_distance that takes in one parameter: distance_to_drive. Use the parameter in your function as the numerator of your fraction.

Use your function to make the robot drive 3 distances in a row.

Tip

Define your functions towards the top of your file, underneath the import statements. This way, code later in the file will be able to use them.

The Encoders

In the last lesson we mentioned encoders. What are they and what do they do?

Encoders are sensors which measure how far each motor (and thus each wheel) has rotated. We mentioned that our motors aren’t perfect, so when we tell them to go a certain effort we don’t know how fast it is actually rotating. Encoders measure exactly what the motor is doing and report this information back to the XRP.

_images/blog017-image001-disks-resolution.jpg

An encoder uses a disk like the one above with alternating clear and black squares. The disk is attached to the output shaft of the motor. A small light is shined through the edge of the disk, and a sensor on the other side sees the light. When a black part of the disk is in front of the light, the sensor sees nothing. When a clear part of the disk is in front of the light, the sensor can see the light. As the disk rotates, the sensor constantly switches from seeing and not seeing the light. The XRP can automatically count how many times it has switched between seeing and not seeing the light, and can use this to calculate how far the wheel has moved.

The size of the black and clear squares determines how precise the encoder is. As the squares get smaller, the light switches more times for the same amount of rotations of the wheel, and thus we can more precisely measure the distance. The downside of having really tiny squares is that the XRP’s processor needs to work harder to keep up with counting all the switches. In the image above you can see some disks with different levels of precision.

Tip

The disk and sensor in the XRP is hidden inside the motor’s plastic case, so you won’t be able to see them.

The XRP handles doing all the math to convert these switches into a real distance measurement for you, so you don’t have to worry about it. We can use some new drivetrain functions to see what the encoders are measuring:

Python

from XRPLib.defaults import *
from time import sleep

while True:
    print(drivetrain.get_left_encoder_position())
    sleep(1)

Blockly

This code uses something new: a while loop. A while loop will run the code underneath it until a condition is no longer equal to True. In this case, the condition is the keyword True, which means that this code will run until True doesn’t equal True. Since this will never happen, the code will run forever unless you stop it manually on your computer.

Tip

You will learn more about loops and conditions later in the course.

The code should run forever, display the drivetrain’s left encoder position, and then wait for one second. Then, it repeats and does this forever. If we didn’t wait for one second, the XRP would read and send the encoder position to your computer as fast as it could (very fast!) which would be too much data for your computer to display at once on the screen.

Try it out

Try running this code to see what happens. Spin the left wheel of the XRP by hand and notice how the number changes.

Calculating distance

Let’s learn a bit about how the XRP uses the encoder to calculate how far the robot has moved.

The XRP knows the diameter of the robot’s wheels; every XRP has the same wheels!

If a car’s wheel rolls on the ground one full revolution, how far does the car move? The car moves by one circumference of the circle:

Tip

Reminder that the circumference of a circle is the distance around it.

The circumference is calculated as \(C = \pi \cdot d\), where \(d\) is the diameter of the circle.

If a car wheel (which is a circle with a circumference of 100 inches) rotates 5 times, how far does the car go? How would you find that?

You would rotate the wheel once, and find that it has traveled 100 inches, because the wheel would trace out it’s circumference on the ground. Then, you would rotate it a second time, and see it move another 100 inches. Then a third, a fourth and a fifth time, and see the wheel has traced out it’s circumference on the ground 5 times.

The amount it has traveled is 5 times the circumference. This can be used for any number of rotations. If you rotate the wheel 3 times, you would move forward 3 times the circumference (300 inches), if you rotated it 1 and a half times, you would move forward one and a half times the circumference (150 inches).

\[d\text{ cm} = (\text{number of rotations}) \cdot (\text{circumference})\]

The XRP uses this equation to automatically calculate how far the wheels have moved in centimeters using the encoders.

Driving a distance (again)

In the last lesson you used a constant speed and a time to drive a distance. Now that you know that the encoders actually measure the distance, it would be better to use them for your drive_distance function. We can modify your function to use a While loop:

Python

def drive_distance(distance_to_drive):
    while drivetrain.get_left_encoder_position() < distance_to_drive:
        drivetrain.set_speed(5, 5)
        time.sleep(0.01)
    drivetrain.stop()

Blockly

This code block uses a loop to constantly check if the left encoder position is less than the distance you want the robot to go. Once it is no longer less than this distance, the loop stops running and the code moves on to the next line. In this case, the next line tells the robot to stop.

Try it out

Replace your drive_distance function with this new one. Try it out next to a meter stick. Is it more or less accurate than before?

Challenge

This code only checks the left encoder. Since both wheels are moving the same speed, this should be fine, but as we said, the motors aren’t perfect. Can you think of a way to combine both encoder values together?

To read the right encoder, you use drivetrain.get_right_encoder_position()

Turning to a heading

Once you know how to drive a certain distance with the XRP, it is easy to turn to a certain heading with it. First, you need to calculate the distance that a wheel must travel so that you are facing the correct heading, and then simply rotate the XRP until the encoders have traveled that distance.

Calculating the necessary distance is complicated, but we can break down this problem into steps.

first, lets make a fraction that represents from 0.0 to 1.0 how far around the robot’s circumference the wheels need to travel. In this case 0.0 is 0 degrees and 1.0 is 360 degrees.

Now to get the distance the wheel travels, we need to multiply this fraction by the total distance the wheel travels to rotate 360 degrees, this number is the circumference of a circle with the diameter same diameter as the robot. We can calculare this by multiplying the wheel track distance by pi.

finally, to get the number of wheel rotations, we need to divide this distance by the circumference of the wheel, or pi times the wheel diameter. We can cancel pi from both sides of this division and that leaves us with.

\[\frac{\text{target degrees} \cdot \text{robot wheel track}} {360 \cdot \text{wheel diameter}}\]

Now that we have the number of wheel rotations, the rest of the program is easy. just turn the robot in the direction of the turn, and stop once the number of rotations has exceeded the calculated rotation goal.

Python

def turn(target):
    global rotations
    differentialDrive.reset_encoder_position()
    rotations = (target * 15.5) / (360 * 6)
    if target > 0:
        differentialDrive.set_effort((-0.3), 0.3)
    else:
        differentialDrive.set_effort(0.3, (-0.3))
    while not math.fabs(motor1.get_position()) >= math.fabs(rotations):

    differentialDrive.stop()

Blockly

Helpful Drivetrain Functions

Throughout this module, we’ve explored different ways to drive forwards and turn, through setting efforts, speeds, and reading the encoders. However, XRPLib also provides some handy functions to make it easy for the user. These functions use more complicated calculations to ensure that the XRP drives smoothly and exactly to the right distance every time.

Python

drivetrain.straight(20, max_effort = 0.5, timeout = None)

Blockly

This function will drive the robot straight forward for a distance in centimeters that you specify. The other two parameters are optional. You can provide a value for them, but if you don’t, the default value will be used.

Calling the function like this: drivetrain.straight(20) will make the robot go straight 20 centimeters, and use the default values for everything else, meaning a maximum effort applied of 50% and no timeout.

You can also use a negative value for distance to drive backwards.

The max_effort parameter specifies how much effort the robot is allowed to apply while driving. By default it is 50%, which is a good effort for normal driving on a flat surface.

The timeout parameter specifies a time, in seconds, that the robot should try to drive before giving up. For example, what if your robot runs into something while driving, and the wheels get stuck? The robot will use the encoders to measure the wheels and notice that it never arrived at the distance you set, so it will try forever and none of your code will run afterwards. The timeout lets you set a maximum time that the XRP should try for before giving up. Usually, you won’t need to use this, but it is there if you need it.

Python

drivetrain.turn(90, max_effort = 0.5, timeout = None)

Blockly

This function is similar to the straight function, except that it rotates the robot instead of driving it forwards.

The turn_degrees parameter lets you tell the robot how many degrees it should turn. Positive values will turn counterclockwise, and negative values turn clockwise.

Try it out

Write code to drive the robot straight for 20 centimeters and then turn 90 degrees clockwise. Don’t forget to add the from XRPLib.defaults import * statement at the top of your program.

Driving With Geometry

The XRP’s driving and turning functions can also be used to draw geometric patterns! By driving a set distance and turning by a certain angle several times, you can draw a shape with as many sides as you want.

Tip

To see the path your XRP has driven, you can place a dry-erase marker between the robot’s wheels and trace your pattern on a whiteboard.

To draw any polygon, you just need to know the size of the shape’s exterior angles, and you need to decide how long the sides should be. Then, you just have to drive straight with the distance of a side length and turn the number of degrees of the corresponding exterior angle. Repeat this until the shape is finished.

Triangle

For a triangle, the interior angles measure 60 degrees and the exterior angles measure 120 degrees. We can trace a triangle with side lengths of 30 cm by having our robot drive straight for 30 cm three times and turn 120 degrees in between each drive straight.

Python

from XRPLib.defaults import *

differentialDrive.straight(30, 0.5)
differentialDrive.turn(120, 0.5)
differentialDrive.straight(30, 0.5)
differentialDrive.turn(120, 0.5)
differentialDrive.straight(30, 0.5)

Blockly

Square

The process for tracing a square is similar to tracing a triangle. The interior angles are 90 degrees so the exterior angles are also 90 degrees. Keeping a side length of 30 cm, we can trace a square by programming our robot to drive straight for 30 cm four times and turn 90 degrees between each drive straight.

Python

from XRPLib.defaults import *

drivetrain.straight(30, 0.5)
drivetrain.turn(90, 0.5)
drivetrain.straight(30, 0.5)
drivetrain.turn(90, 0.5)
drivetrain.straight(30, 0.5)
drivetrain.turn(90, 0.5)
drivetrain.straight(30, 0.5)

Blockly

Polygons

We can generalize the procedure used to make a triangle and square to make any regular polygon; you just have to determine the exterior angle and choose a side length. However, for polygons with many sides, this process can get very tedious. Instead of repeating the same code multiple times, we can use a function to simplify the process.

First, lets determine what information the function needs. To trace a polygon, you need to determine the number of sides and the length of each side. We can create a function that takes these two values as an input. The function will drive the distance we give it, turn by the exterior angle, and then repeat that process as many times as there are sides in the shape. We can use a loop for this. The one problem is: how do we know the measure of the exterior angles? Fortunately, this can be easily calculated with this equation:

\[360/n\]

With the variable n representing the number of sides of your polygon, this equation determines the number of degrees of your polgyon’s exterior angles. With this information, you can now write a function to trace any regular polygon!

Python

from XRPLib.defaults import *

def polygon(sideLength, numSides):
    for i in range(int(numSides)):
        differentialDrive.turn((360 / numSides), 0.5)
        differentialDrive.straight(sideLength, 0.5)

Blockly

Pinwheel

Now we know how to easily draw any polygon, but we can take it one step further and draw a polygon pinwheel. This pattern consists of several polygons extending out from a center point. Your XRP can execute this by tracing several polygons consecutively and turning slightly between each new polygon. A pinwheel of 3 squares should look something like this:

Programming this may seem like a daunting task, but it is actually quite simple. Every time you want to trace a piece of the pinwheel, you just need to call your polygon function from before and then turn your robot slightly. We can calculate the measure of this turn by dividing 360 degrees by the number of polygons we are tracing in order to keep even spacing between each polygon. Repeat this process as many times as there are polygons in the pinwheel, and your pattern will be finished!

Python

from XRPLib.defaults import *

def pinwheel(sideLength, numSides, numShapes):
    for i in range(numShapes):
        polygon(sideLength, numSides)
        drivetrain.turn(360 / numShapes, 0.5)

Blockly

Waiting for Button Input

You may have noticed that your code runs immediately after uploading it. This is nice sometimes, but sometimes you aren’t coding in the same place you will be running your code, and the robot suddenly driving itself off the table isn’t an ideal result. In order to have the code run on command, we can use the on board buttons to tell the code when to run.

The XRP has a button which you can read from code. To make it easy, XRPLib has a built in function which will wait for the button to be pressed for you.

Python

from XRPLib.defaults import *
from time import sleep

board.wait_for_button()
sleep(1)
drivetrain.straight(20)

Blockly

This function is part of board since the button is on the XRP’s main controller board.

This code will wait until the button is pressed, and then wait an additional 1 second (for you to get your finger out of the way) and then start driving.

There is also a function which lets you read the current state of the button without waiting for it:

board.is_button_pressed()

You could use this function as the condition for a while loop if you wanted to do something more complicated with the button than just waiting for it.

Parking Challenge

Challenge Description

This challenge features a sequence of turns that the robot must perform in order to get to the “end” of the Labyrinth. The robot must first begin at the starting point, and get to the goal area by completing turning and forward movement behaviors.

Materials needed

White board or six 8.5”x11” sheets of paper (use scotch tape to tape the six sheets of paper together to form a 25.5”x22” rectangle. Turn it over and tape outside border to floor with blue masking tape.
Black electrical tape (you can substitute blue masking tape for this exercise)
Red electrical tape or red marker
Scissors (or cutting tool)
Ruler (or straightedge)

Project specifications

_images/labyrinth.png — Carnegie Mellon Robotics Academy, Labyrinth Challenge

The robot should do the following:

Begin fully contained in position 1 and then maneuver to goal area.
Reach and be fully contained within position 2 without crossing any black lines.

Advanced: Circles and Differential Steering

In this section, we derive the math needed to drive in circles of any radius. Fundamentally, this requires driving the two motors at different ratio, but it takes a little calculation to figure out this ratio for a given radius.

The robot goes in an arc. The wheels draw out 2 different circles with 2 different radii. The arc with the smaller radius (\(r_1\), the white line) has a smaller circumference. That means the left wheel has driven a smaller distance. It has gone slower.

How would you drive in an arc with a given radius?

We know the wheels trace out arcs when we make the wheels go at different speeds, but how do we decide what the wheel speeds should be?

What do we know?

Let us start with what we know about the two arcs, and the arc we want the center of the robot to go through.

The first thing we can say about any circle is that the radius is proportional to the circumference. This means that the inner and outer arc lengths are proportional to the inner and outer radii, or

\[\frac{\text{left wheel distance}}{\text{right wheel distance}} = \frac{r_1}{r_2}\]

This means that the ratio between the wheel speeds is equal to \(\frac{r_1}{r_2}\).

Hey! We found out what the ratio between the wheel speeds is supposed to be if we know the two radii. But how do we find what the two radii are? We only know what we want the radius of the orange circle to be.

But we know what the distance between the two wheels are.

If \(r_{bot}\) is the distance between the two wheels, then

\[r_1 = r_{desired} - \frac{r_{bot}}{2}\]

since r1 is less than the desired radius, and

\[r_2 = r_{desired} + \frac{r_{bot}}{2}\]

We found out the radii of the circles we want the left and right wheels to trace, and we know how to find the ratio between the wheel speeds from that.

Remember:

\[\text{ratio between wheel speeds} = \frac{r_1}{r_2}\]

Putting them together, we get,

\[\text{ratio between wheel speeds} = \frac{r_{desired} - \frac{r_{bot}}{2}}{r_{desired} + \frac{r_{bot}}{2}}\]

Try it out

Write code to make the robot drive in a circle. Use the set_speed function, and use a speed of 5 cm per second for the left wheel speed. Use the ratio you calculated to find out what the right wheel speed should be (multiply 5 by the ratio)

Now try using 5 for the right wheel speed, and use the ratio for the left wheel. What happened?

Additional challenges

Try to make the robot do a point turn! What is the radius of the circle that you want it to drive in then?

Try and make the robot turn around one of the wheels. What is the new desired radius?

Try making the robot drive backwards in an arc

Manipulation: Module Overview

In this module students will:

Understand the basics of manipulation and its application
Learn how to control their XRP’s robot arm

At the end of this module, students will be able to:

Write a quick program for controlling the robot arm
Implement custom functions for controlling the robot arm
Manipulate their environment using the robot arm

Covered Standards (NGSS and CSTA):

HS-ETS1-2 Break a complex real-world problem into smaller, more manageable problems that each can be solved using scientific and engineering principles.

3A-AP-16 Design and iteratively develop computational artifacts for practical intent, personal expression, or to address a societal issue by using events to initiate instructions.

3A-AP-17 Decompose problems into smaller components through systematic analysis, using constructs such as procedures, modules, and/or objects.

3B-CS-02 Illustrate ways computing systems implement logic, input, and output through hardware components.

3B-AP-10 Use and adapt classic algorithms to solve computational problems.

3B-AP-11 Evaluate algorithms in terms of their efficiency, correctness, and clarity.

3B-AP-15 Analyze a large-scale computational problem and identify generalizable patterns that can be applied to a solution.

3B-AP-16 Demonstrate code reuse by creating programming solutions using libraries and APIs.

Introduction to Manipulation

Now that we’ve covered different ways of controlling your robot’s movement, let’s cover how we can control the robot’s arm to manipulate our environment.

The XRP Arm

Every robot needs to be able to interact with it’s environment.

Your XRP does this with a simple 1 DOF arm.

In this case, “DOF” stands for “Degree of Freedom” and refers to the number of ways the arm can move.

Accurate Control of the XRP arm

To move your XRP’s arm, use this function:

servo.set_angle(angle)

In this case, the function takes in a single argument, which is the angle in degrees that you want the arm to move to. The angle has a range of [0, 135] degrees.

Try it out

Try writing code that moves the arm to an angle of 90 degrees, sleeps for 1 second, and then moves the arm back to an angle of 0 degrees.

Other Robotics Manipulators

There are many types of robotic manipulation. Here is a very complicated example, where Boston Dynamics’ Spot robot opens a door and lets itself in.

The XRP arm is a very simple manipulator.

Most robots have more complex manipulators, with more degrees of freedom.

For example, Boston Dynamic’s Spot robot has a 5 DOF arm that can be used to open doors, turn valves, and even pick up objects.

For more complicated manipulators like the one that Spot has, roboticists often have to create control laws specific to those manipulators.

In the case of Spot, the arm is equipped with a camera that help Spot better understand it’s environment and avoid obstacles while trying to use it’s arm.

Picking up a Basket

Now that we’ve covered how to move the XRP arm to specific angles, we can start to think about how to use the arm to pick up objects. In this section, we’ll cover how to use the arm to pick up a basket which is one of the challenges for your final project described in detail in the next module.

The Process

Let’s first think about what the process of picking up a basket would look like. Imagine the a small paper cup with a bail attached over the top to that you can hook with the servo arm. An example of a basket is shown in the video below.

An example of the steps required to aquire the basket are:

Lower the arm to a height where it will be inside the bail.
Back up the robot so that the arm goes inside the bail.
Raise the arm to lift the bucket off the ground.
Drive away carying the bucket.

Now the robot can drive away while carrying the basket.

Try placing your robot in front of a basket and then writing a program to pick it up as shown in the following video.

Integrating Locating and Pickup

Now that we’ve covered how to pick up a basket, we can start to think about how to integrate this with code that we have previously written to locate a nearby object.

To do this, you will re-use the code that you have written to how execute the pickup process when the robot is in front of the basket.

Intersection into Drop Off

Now that we’ve learned how to detect an intersection and develop custom functions, let’s try to put it all together to create a program that can drop a basket off at a designated location.

The Process:

Let’s first think about the process:

We want to first detect an intersection and know that we can accomplish this by waiting for both line sensors to detect a line.

Once we detect an intersection, we want to turn 180 degrees to ensure that we are facing the correct direction to drop off the basket.

Then, we want to travel a certain distance to ensure that we are at the correct location to drop off the basket.

Once we are at the correct location, we want to drop off the basket.

Then, we want to drive back to the intersection. Since we are already facing “backwards”, this means that we don’t have to correct our orientation before returning to the intersection.

Finally, we want to put the arm back into the starting position and start line following again.

Put together, this process can be broken into these steps:

Detect an intersection
Turn 180 degrees
Travel our desired distance
Drop off the basket
Drive back to the intersection
Put the arm back into the starting position
Start line following again

We can use the functions we’ve already created to do this:

Error

TODO add code and a video

Delivery Challenge: Module Overview

The delivery robot has to bring packages from one location to another. Introduction To help people in need in the current pandemic, you and your colleagues have decided to build an autonomous delivery robot.

Your robot will pick up food and other supplies and deliver them to residences with minimal contact, all to help fight the spread of the coronavirus.

Of course, a full-sized version will have to wait until you get millions of dollars in investments for your robotics company, but that doesn’t mean you can’t have fun dreaming with a scale model here.

Your robot will have an arm for lifting and carrying “bags” of goods and sensors to help it navigate a simple network of “streets.” Complicating things a little, not everything to be delivered is always put in the right spot for easy collection and sometimes road construction might block your path. But you’ll still need to make it work!

The world is counting on you! Can you make it happen?

Objectives

The final project is a chance for you and your teammates to demonstrate that you can apply concepts and strategies from the course to a specific challenge. You will apply theoretical knowledge to the design of your system and use focused testing to improve the performance. The project will culminate in a demonstration where you will prove your robot’s performance. To help us understand more about your system and your process, you will also produce a report describing the system development and an assessment of how well it met your goals.

The successful team will design, build, and demonstrate a robot that can accomplish a prescribed set of tasks. To be successful, you will need to:

Identify key performance criteria and develop a strategy for meeting your team’s objectives, Identify key factors that affect performance and use analysis and testing to specify them, Develop and apply a testing strategy to ensure performance, Evaluate the system performance, and Describe the system and your design process.

Challenge

Your challenge is to program your robot to pick up bags of supplies from known and unknown locations and deliver them to specified delivery points. The challenge is constructed such that the tasks have a range of difficulty. For example, located the free range bag and scoring them will earn more points, as will being able to navigate around the construction sign. Since you will have to perform multiple runs, reliability will be essential.

Course

The course will consist of a strip of tape (to simulate roads) with a designated place to pick up bags and three specified drop zones. Most bags will be placed at the end of the main road, though some will be placed in a “free range” zone. Figure 1 shows a typical arena, though we realize that there will be some variation in each course.

Figure 1: Diagram of the arena. Individual arenas will vary.

Bags

You will be expected to build your own delivery bags, for example from paper or card stock and paper clips. You should have at least two bags ready for the demo. You may “recycle” them as the demo progresses. Here is an example of an easy to make bag that can be constructed from a drink disposable cup you might find in a restaurant.

Figure 2: Example of a bag for the delivery challenge

Collection

Most of the bags will be placed on the line at the end of the main road. You may place a piece of tape near the pickup zone to indicate where it starts, but the bags will be placed at different distances from the tape.

To earn points for collecting the free-range bag, you must demonstrate that its position can be arbitrary within the free-range zone (with the exception that you may face the bail in whatever position you deem most favorable).

Delivery zones

Each delivery zone or platform may be no larger than 10 cm in any horizontal dimension. The platforms for the delivery zones will be marked on the ground. You can make them out of cardboard or any other material. To score points, each container must be placed in a delivery zone and left there (upright) long enough to prove that it is stable.

Operation

You will start with your robot on the main road and a bag in the pickup zone. On command (a press of either button on the robot), your robot will drive to the pickup zone, pick up a bag, and deliver it to the specified address, which will be determined by the button press (e.g., ’GP20’ indicates a delivery to address A, etc.). Your robot will then return to the starting point, stop, and wait for the next command.

After each delivery, you will place another bag in the pickup zone and repeat the process, pressing the button to indicate another delivery. You may recycle the bags as much as you wish.

At two random points in the demo, your instructor will place a road construction sign on the main road for 30 seconds, and you will not receive credit for any delivery during which your vehicle hits the sign.

The challenge will last 5 minutes. You may use any of the sensors that you’ve explored in this class to accomplish the challenge. Line following will be an important behavior, but collecting the free-range bags autonomously will require some creativity on your part.

[Video of a sample run coming soon!]

Scoring

[Tune point values over time]

In your run, your team should deliver as much weight as possible, plus and including the “free range” bags. Points will be allocated as follows:

You will receive 5 point for every package you deliver to addresses A or C. However, you may only get 50 points max (corresponding to 10 packages) for each delivery address; i.e., you must deliver to all three addresses to receive the maximum points. You will receive 5 additional points for each free-range bag (20 points max) scored at address B. Your total score will be multiplied by the number of unique addresses you delivered bags to. That is to say, if you scored 1 bag to Address A, and 1 bag to Address B, your final score would be 2 * (5+5) = 20 points. If you scored a free range bag on top of that, your score would be 3 * (5+5+5) = 45 points No points will be received for a delivery where the robot hits the road construction sign. You will lose 2 points for each time you have to touch your robot (e.g., to put it back on the line), other than to specify the delivery zone at the start of each delivery.

Covered Standards (NGSS and CSTA):

HS-ETS1-2 Break a complex real-world problem into smaller, more manageable problems that each can be solved using scientific and engineering principles.

HS-ETS1-3 Evaluate a solution to a complex real-world problem based on prioritized criteria and tradeoffs that account for a range of constraints, including cost, safety, reliability, aesthetics, and maintenance, as well as social, cultural, and environmental impacts.

3A-AP-16 Design and iteratively develop computational artifacts for practical intent, personal expression, or to address a societal issue by using events to initiate instructions.

3A-AP-17 Decompose problems into smaller components through systematic analysis, using constructs such as procedures, modules, and/or objects.

3B-CS-02 Illustrate ways computing systems implement logic, input, and output through hardware components.

3B-AP-10 Use and adapt classic algorithms to solve computational problems.

3B-AP-11 Evaluate algorithms in terms of their efficiency, correctness, and clarity.

3B-AP-15 Analyze a large-scale computational problem and identify generalizable patterns that can be applied to a solution.

3B-AP-16 Demonstrate code reuse by creating programming solutions using libraries and APIs.

Experiential Robotics Platform (XRP)

What Is the XRP Platform?

Welcome to Introduction to Robotics

Getting Help

Discourse

GitHub issues

Introduction to the XRP: Module Overview

What is a robot

Examples

Radio Controlled Airplane

Drone

Vacuum cleaner

Autonomous vacuum cleaner

Self-driving car

What are the parts of robotics?

Building the XRP Robot

Installing the programming tools

Blockly

Python

Robot Driving: Module Overview

Covered Standards (NGSS and CSTA):

Understanding Your Robot’s Drivetrain

Introduction

Driving straight

Turning in an arc

Turning in place

Turning on one wheel

Effort

First movements

Going backwards

Getting the Robot Moving

Basic driving

Driving a Distance

Controlling your speed

Driving a distance

The Encoders

Calculating distance

Driving a distance (again)

Turning to a heading

Helpful Drivetrain Functions

Driving With Geometry

Triangle

Square

Polygons

Pinwheel

Waiting for Button Input

Parking Challenge

Challenge Description

Materials needed

Project specifications

Advanced: Circles and Differential Steering

How would you drive in an arc with a given radius?

What do we know?

Additional challenges

Measuring Distances: Module Overview

Covered Standards (NGSS and CSTA):

Measuring Distances

Animal Echolocation

Robotic Echolocation

Reflective sensors

Mechanical Sensors

Using the Ultrasonic Sensor

Obstacle Avoidance

Step 1: Going forward a certain distance

Step 2: Turing 180 degrees once an object is detected

Step 3: Turing a random angle once an object is detected

Locating a Nearby Object

Turn and Detect

Improving Accuracy

Implementing Dual Edge Detection

Robot Control: Module Overview

Covered Standards (NGSS and CSTA):

Controlling Behavior: Introduction

Open Loop Control

Closed Loop Control

Python Programming Note: Conditionals

On-off Control

Distance Tracking

The Process

Introduction to Proportional Control