back to Index

Important Information

The API:

r.drive(left, right) makes the motors move. The values range from -1 to 1.

Quickstart-Robot

Let's make a robot drive forward:

Click on the cell below, and press `SHIFT` + `ENTER` to run

In [15]:
import lbot, time, IPython, sys, time
r = lbot.Robot()
r.drive(.1, .1)

The robot should now be driving forward!

Stop the robot by running the cell below:


In [16]:
r.drive(0,0)

Robot Commands

In the empty cell below, try making the robot spin to the right:

Click on the cell below ("Your code goes here!~") and start typing code!

In [13]:
r.drive(.2, .05)

Then, in the empty cell below, try to make the robot stop.


In [14]:
r.drive(0,0)

now, try making the robot drive backwards:


In [11]:
r.drive(-.1, -.1)

How to use this interface

These code blocks are called cells.

The menu and toolbar:

Try clicking on Insert ==> Insert Cell Below.


In [ ]:

Fancy Robot Commands

By making new cells below this one, try commanding the robot to drive in different radius circles.

Make a cell below here that spins the robot in ~5 inch diameter circles. (Don't spend too much time tuning)


In [62]:
r.drive(.2, -.025)

In [63]:
r.drive(0,0)

Make a cell below here that spins the robot in ~10 inch diameter circles. (Don't spend too much time tuning)


In [77]:
r.drive(.6,.05)

In [89]:
r.drive(0,0)

Robot Trajectories

Commands can be strung together to make a robot follow paths.

Compare the behavior of the two cells, and try to record an explaination:


In [79]:
r.drive(0,.2)
r.drive(0,0)
Double click on the cell below ("What happened: Why:") to record your thoughts. Press `SHIFT` + `ENTER` to render the text.

What happened: The robot moved a little then stopped

Why: The lines got executed one after another


In [80]:
r.drive(.15,.15)
time.sleep(.5)
r.drive(0,0)

What happened: THe robot moved quite a bit then stopped

Why: the time.sleep line allowed the code above to last for a longer amount of time so it continued driving lonver

Using Robot Trajectories with Sleep

Try making the robot turn 90 degrees using what you've learned (hint: time.sleep might help!)


In [83]:
r.drive(.3,-.3)
time.sleep(.5)
r.drive(0,0)

Try making the robot drive 5 inches.


In [84]:
r.drive(.15,.15)
time.sleep(.5)
r.drive(0,0)

Now, use these together to make the robot drive forwards, turn 180 degrees, drive back, and then turn back to the original angle.


In [87]:
r.drive(.15,.15)
time.sleep(.5)
r.drive(0,0)

r.drive(.3,-.3)
time.sleep(.9)
r.drive(0,0)

r.drive(.15,.15)
time.sleep(.5)
r.drive(0,0)

Variables

We can pass variables to functions:


In [88]:
left = .1
right = .1

r.drive(left, right)

We can also assign variables:


In [90]:
left = .1
right = .1

print left
print right

left = left * 2

print left
print right

r.drive(left, right)


0.1
0.1
0.2
0.1

In [69]:
r.drive(0,0)

In [101]:
for i in range(10):
    value = i*5
    print i
    print value


0
0
1
5
2
10
3
15
4
20
5
25
6
30
7
35
8
40
9
45

Using Robot Trajectories With loops

Now, using the for loop, make a robot drive in a square:


In [95]:
for i in range(4):
    r.drive(.15,.15)
    time.sleep(.5)
    r.drive(0,0)

    r.drive(.3,-.3)
    time.sleep(.5)
    r.drive(0,0)

    r.drive(.15,.15)
    time.sleep(.5)
    r.drive(0,0)

Sensors

Run the cell below a couple times under various lighting conditions. For example, try:

  • facing up
  • on retro-reflective tape
  • on carpet
  • on the table surface
Press `CTRL` + `ENTER` to run a cell repeatedly while the cell is selected

In [37]:
reflectances = r.read_sensors()
print reflectances
print len(reflectances)


(0.5501831769943237, 0.16239316761493683, 0.058363862335681915, 0.11428572237491608, 0.07130647450685501, 0.35164836049079895)
6

The output of read_sensors is a tuple: a group of values.


In [38]:
tups = (12, -1)
print tups
print len(tups)


(12, -1)
2

In [27]:
print tups[0]
print tups[1]


12
-1

Use the examples above to print out the value of the third reflectance sensor.


In [28]:
# Your code goes here!~

Use your knowlege of loops and tuples to print all the values of read_sensors.


In [65]:
# Your code goes here!~
for i in range(len(reflectances)):
    print reflectances[i]


0.550183176994
0.162393167615
0.0583638623357
0.114285722375
0.0713064745069
0.351648360491

Streaming data


In [51]:
for i in range(5):
    print i
    time.sleep(1)


0
1
2
3
4

In [50]:
for i in range(5):
    IPython.display.clear_output()
    print i
    sys.stdout.flush()
    time.sleep(1)


4

Streaming the reflectance values

Try this:

(To stop it remember that there is a stop button in the toolbar ar the top)


In [66]:
while True:
    values = r.read_sensors()
    IPython.display.clear_output()
    for val in values:
        print '='*int(100*val) + int(100*(1.-val))*' ' + str(val)
    sys.stdout.flush()
    time.sleep(.01)


========================================                                                           0.40879124403
======                                                                                             0.0686202719808
=====                                                                                              0.0539682582021
=====                                                                                              0.0566544607282
=====                                                                                              0.0559218600392
=======                                                                                            0.0769230797887
---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
<ipython-input-66-1b95efd91b58> in <module>()
      1 while True:
----> 2     values = r.read_sensors()
      3     IPython.display.clear_output()
      4     for val in values:
      5         print '='*int(100*val) + int(100*(1.-val))*' ' + str(val)

/home/ajc/topgear/odroid/topgear/lbot.pyc in read_sensors(self)
     21         lc.subscribe('robot0/state', callback)
     22         while c.values is None:
---> 23             lc.handle()
     24         return c.values

KeyboardInterrupt: 

Let's explore comparisons!


In [ ]:
5 < 4

In [ ]:
5 > 4

In [ ]:
5 >= 4

In [ ]:
4 >= 4

In [ ]:
4 <= 3

In [ ]:
5 == 4

In [ ]:
5 == 5.0

In [ ]:
5 != 4

In [ ]:
2 + 2 == 4

In [ ]:
2 >= 3

What do the following comparison operators do?

  1. ">":

  2. "<":

  3. ">=":

  4. "<=":

  5. "!=":

Playing with logicals

See if the value read in by the first sensor is greater than or equal to .3

Store the result in variable boo


In [ ]:
# Your code goes here!~

Now let's use sensors while driving the robot

Try to do the following:

  • Set the robot to be perpendicular to some retro reflective tape a few inches away

  • Let the robot drive until the robot reaches the tape

  • Run the cell multiple times for varrying distance from the reflective tape.

Think about your tests under different lighting conditions and logical operators.


In [74]:
# Your code goes here!~
r.drive(.15,.15)
temp = r.read_sensors()
while temp[0] > .4:
#     r.drive(.15,.15)
    temp = r.read_sensors()
r.drive(0,0)

In [75]:
# Your code goes here!~
r.drive(.15,.15)
# temp = r.read_sensors()
while r.read_sensors()[0] > .4:
    time.sleep(.001)
r.drive(0,0)

Now put the robot on reflective tape parallel to it and have it drive until it is off the reflective tape.


In [58]:
# Your code goes here!~

Congratulations, you are on your way to follow a line!

Conditionals

The final step to make to follow lines is learning about conditionals


In [59]:
temp = 0

if temp > 8:
    print "hello"
else:
    if temp > 4:
        print "bye"
    else:
        print "Your number is too small"


Your number is too small

In [ ]: