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)



In [69]:

    
r.drive(0,0)



In [101]:

    
for i in range(10):
    value = i*5
    print i
    print value

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]

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)



In [50]:

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

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?

">":
"<":
">=":
"<=":
"!=":

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 [ ]: