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
The main body of your Rosmo is called the drivetrain. We call it this because it holds the two wheels which drive your robot around. Specifically, the Rosmo has a differential drivetrain. This is the same kind of drivetrain that you would see on a skid-steer loader.
.. image::  :width: 300
](https://raw.githubusercontent.com/Open-STEM/IntroToRoboticsV2/main/course/driving/!%5B%5D(https://raw.githubusercontent.com/Open-STEM/IntroToRoboticsV2/main/course/driving/media/skidSteerLoader.png)){kind=link}
.. image:: 
The Rosmo 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 Rosmo'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:
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.
.. image:: 
:width: 300
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.
.. image:: 
:width: 300
One advantage the Rosmo 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.
.. image:: 
:width: 300
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.
.. image:: 
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.
.. youtube:: z6aIVpf3qN0
.. youtube:: Zcr83kcO_Pk
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.
.. note::
Elevate your Rosmo 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 Rosmo programming environment and check that your Rosmo itself is working properly.
.. admonition:: Try it out
Create a new file in the IDE called :code:`spin_wheels.py`. Add the
following code to it:
.. code-block:: python
from RosmoLib.defaults import *
left_motor.set_effort(0.5)
Run the code and see what happens.
Let's break down the code line by line:
:code:from RosmoLib.defaults import * tells your robot to load code from
RosmoLib. 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 Rosmo
programs.
:code:left_motor.set_effort(0.5) uses a function provided for you in RosmoLib
called :code:set_effort that is applied to the left motor. The :code:0.5 is a parameter to
this function which tells it that we'd like the motor to apply 50% effort.
On the Rosmo, we write percentages as decimal numbers between 0 and 1, with 1 being 100%.
.. Explain functions in greater depth later on (pinwheel activity?)
.. A function is a block of code that can be used multiple times in your program
.. to make complicated tasks easier. For example, the
.. :code:left_motor.set_effort() function tells the left motor to apply an effort
.. you as the programmer specify.
.. :code:left_motor.set_effort is a function that we provide for you in
.. RosmoLib. Later in the course you will see how you can write your own
.. functions to make it easy to make the robot do complicated sequences of actions.
.. When you want to use a function, you call it by writing its name in your code. .. This causes the function's code to start running.
.. The number you put between the parenthesis is a parameter (sometimes also .. called called an argument) of the function. These allow you to tell the .. function how it should do its job. As the programmer, you must provide a value .. for each parameter. If we wanted to make the robot drive forwards at full .. speed, we would call the function like this:
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
:code:left_motor with :code:right_motor.
.. admonition:: 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.
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.
.. admonition:: 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:
.. list-table:: :header-rows: 1
-
- 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
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 Rosmo on a flat surface like a table or the floor.
Getting your Rosmo robot to move is simple! Here is some code you can use to drive both the left and right motors at 50% effort:
.. tab-set::
.. tab-item:: Python
.. code-block:: python
from RosmoLib.defaults import *
drivetrain.set_effort(0.5, 0.5)
.. tab-item:: Blockly
.. image:: 
.. tab-item:: Blockly
.. image:: , we can calculate how many seconds we should drive for to reach that distance.
Let's use :math: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:
.. math:: (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
:math:5 \text{ cm} = 1 \text{ second}. Rearranging, we have our special representation of 1:
.. math::
\frac{1 \text{ second}}{5 \text{ cm}} = 1
We can now multiply our expression with this special representation of 1:
.. math:: (d \text{ cm}) \cdot \frac{1 \text{ second}}{5 \text{ cm}}
Cancelling out units and simplifying, we obtain:
.. math:: (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 :math:\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 :math:\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.
.. admonition:: 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:
:code:sleep, which makes the Rosmo wait for some number of seconds before
continuing to the next instruction in the code.
.. tab-set::
.. tab-item:: Python
.. code-block:: python
from RosmoLib.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
.. tab-item:: Blockly
.. image:: ![](https://raw.githubusercontent.com/Open-STEM/IntroToRoboticsV2/main/course/driving/media/setspeedandsleep.png
:width: 300
.. tip::
The :code:`#` 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.
.. admonition:: Try it out
Add the code to your program and try it out. Remember to replace :code:`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:
.. add blockly tab once math can be inputted into "sleep" block .. code-block:: python
from RosmoLib.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
:code: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.
.. tab-set::
.. tab-item:: Python
Python uses the keyword :code:`def` to let you, the programmer, tell it that you
would like to *define* a new function. A full function definition looks like
this:
.. code-block:: python
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.
.. tab-item:: 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 :code:`text`, and uses
prints the :code:`text` value. Functions can have as many or as few parameters as you want,
or even have no parameters at all.
.. image:: ![](https://raw.githubusercontent.com/Open-STEM/IntroToRoboticsV2/main/course/driving/media/blocklyfunctiondefinition.png
:width: 300
The below blocks *calls* the function we defined above to run it. The value "Hello" is passed
to the :code:`text` parameter, which results in "Hello" being printed to the console.
.. image::  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 Rosmo.
.. image:: 
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 Rosmo 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 Rosmo'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 Rosmo is hidden inside the motor's plastic case, so
you won't be able to see them.
The Rosmo 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 :code:drivetrain functions to see what the encoders are measuring:
.. tab-set::
.. tab-item:: Python
.. code-block:: python
from RosmoLib.defaults import *
from time import sleep
while True:
print(drivetrain.get_left_encoder_position())
sleep(1)
.. tab-item:: Blockly
.. image::  which would be too much data for your computer to display at once on the screen.
.. admonition:: Try it out
Try running this code to see what happens. Spin the left wheel of the Rosmo
by hand and notice how the number changes.
Let's learn a bit about how the Rosmo uses the encoder to calculate how far the robot has moved.
The Rosmo knows the diameter of the robot's wheels; every Rosmo 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:
.. image:: 
.. tip::
Reminder that the circumference of a circle is the distance around it.
The circumference is calculated as :math:`C = \pi \cdot d`, where :math:`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?
.. image:: 
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).
.. math::
d\text{ cm} = (\text{number of rotations}) \cdot (\text{circumference})
The Rosmo uses this equation to automatically calculate how far the wheels have moved in centimeters using the encoders.
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 :code:drive_distance function. We can modify your
function to use a :code:While loop:
.. tab-set::
.. tab-item:: Python
.. code-block:: 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()
.. tab-item:: Blockly
.. image:: `
Once you know how to drive a certain distance with the Rosmo, 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 Rosmo 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.
.. math::
\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.
.. tab-set:: .. tab-item:: Python .. code-block:: 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()
.. tab-item:: Blockly
.. image:: 
.. tab-item:: Blockly
.. image::  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 :code: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 :code: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 Rosmo should try for before giving
up. Usually, you won't need to use this, but it is there if you need it.
.. tab-set::
.. tab-item:: Python
.. code-block:: python
drivetrain.turn(90, max_effort = 0.5, timeout = None)
.. tab-item:: Blockly
.. image:: 
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.
.. tab-set::
.. tab-item:: Python
.. code-block:: python
from RosmoLib.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)
.. tab-item:: Blockly
.. image:: 
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)
.. tab-item:: Blockly
.. image:: :
for i in range(int(numSides)):
differentialDrive.turn((360 / numSides), 0.5)
differentialDrive.straight(sideLength, 0.5)
.. tab-item:: Blockly
.. image:: 
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!
.. tab-set::
.. tab-item:: Python
.. code-block:: python
from RosmoLib.defaults import *
def pinwheel(sideLength, numSides, numShapes):
for i in range(numShapes):
polygon(sideLength, numSides)
drivetrain.turn(360 / numShapes, 0.5)
.. tab-item:: Blockly
.. image:: 
- Red electrical tape or red marker
- Scissors (or cutting tool)
- Ruler (or straightedge)
.. figure:: 
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.