back to Index

Quickstart-Robot

Let's make a robot drive forward:

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



In [2]:

    
import lbot, time, IPython, sys, time
r = lbot.Robot()
r.drive(.1, .1) # range [-1.0 ... 1.0]

The robot should now be driving forward!

Stop the robot by running the cell below:



In [3]:

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

    
# Your code goes here!~
r.drive(.1,0)

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



In [19]:

    
# Your code goes here!~
r.drive(0,0)

now, try making the robot drive backwards:



In [6]:

    
# Your code goes here!~
r.drive(-.1,-.1)

How to use this interface



In [ ]:

These code blocks are called cells.

The menu and toolbar:

Try clicking on Insert ==> Insert Cell Below.

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

    
# Your code goes here!~
r.drive(.3,.1)



In [41]:

    
# Your code goes here!~
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 [ ]:

    
# Your code goes here!~



In [ ]:

    
# Your code goes here!~

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

    
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: It moved a little and stopped.

Why: First command told the robot to move forward and then the second command told it to stop completely.



In [48]:

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

What happened: The robot moved forward by .5 seconds.

Why: The first command told the robot to move forward. Second command set a time limit of .5 seconds. Third command told the robot to stop completely.

Using Robot Trajectories with Sleep

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



In [55]:

    
# Your code goes here!~
r.drive(.3,0)
time.sleep(1.0)
r.drive(0,0)

Try making the robot drive 5 inches.



In [52]:

    
# Your code goes here!~
r.drive(.2,.2)
time.sleep(1.0)
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 [58]:

    
# Your code goes here!~
r.drive(.2,.2)
time.sleep(1.0)
r.drive(0,0)
r.drive(.3,0)
time.sleep(1.5)
r.drive(0,0)
r.drive(.2,.2)
time.sleep(1.0)
r.drive(0,0)
r.drive(.3,0)
time.sleep(1.5)
r.drive(0,0)

Variables

We can pass variables to functions:



In [60]:

    
left = .1
right = .1

r.drive(left, right)

We can also assign variables:



In [ ]:

    
left = .1
right = .1

print left
print right

left = left * 2

print left
print right

r.drive(left, right)



In [ ]:

    
r.drive(0,0)



In [61]:

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

    
# Your code goes here!~
for i in range(4):
    r.drive(.2,.2)
    time.sleep(1.0)
    r.drive(.3,0)
    time.sleep(1.0)
    r.drive(0,0)



In [68]:

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

    
reflectances = r.read_sensors()
print reflectances
print len(reflectances)









    



(0.7252747416496277, 0.4332112669944763, 0.36166056990623474, 0.4442002773284912, 0.44468867778778076, 0.3560439646244049)
6

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



In [72]:

    
tups = (12, -1)
print tups
print len(tups)









    



(12, -1)
2



In [73]:

    
print tups[0]
print tups[1]

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



In [74]:

    
# Your code goes here!~
print reflectances[2]









    



0.361660569906

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



In [87]:

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









    



0.72527474165
0.433211266994
0.361660569906
0.444200277328
0.444688677788
0.356043964624

Streaming data



In [86]:

    
for i in range(5):
    print i
    time.sleep(1)



In [77]:

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

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









    



========================     0.825396895409
=                            0.0605616644025
=                            0.0388278402388
=                            0.0437118448317
======                       0.231257647276
=======================      0.795360267162






    



---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
<ipython-input-79-0ab325617f74> in <module>()
      5         print '='*int(30*val) + int(30*(1.-val))*' ' + str(val)
      6     sys.stdout.flush()
----> 7     time.sleep(1)

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

    
# Your code goes here!~
i = reflectances[0] >= .3
print i









    



True

Conditionals

Play with the code below to understand conditionals.



In [82]:

    
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

Try printing a tuple of Booleans (True or False) that indicates if a sensor is on the tape line.



In [129]:

    
# Your code goes here!~
reflectances = r.read_sensors()
i = reflectances[0] <= .71
print reflectances
print i









    



(0.04493284597992897, 0.04981685429811478, 0.06471306830644608, 0.7047619223594666, 0.6915751099586487, 0.8058608770370483)
True

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

    
# Your code goes here!~
r.drive(.1,.1)
while True: 
    reflectances = r.read_sensors()
    if reflectances[0] <.1:
        r.drive(0,0)









    



---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
<ipython-input-153-928e84b45c87> in <module>()
      2 r.drive(.1,.1)
      3 while True:
----> 4     reflectances = r.read_sensors()
      5     if reflectances[0] <.1:
      6         r.drive(0,0)

/home/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
     25     def read_joysticks(self):

KeyboardInterrupt:



In [ ]:

    
# Your code goes here!~
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 [ ]:

    
# Your code goes here!~

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

Reading Joysticks

Run the cell below, and try graphing the values using examples above.

You will need to jiggle the joysticks to read values.



In [ ]:

    
r.read_joysticks()

Try making the robot drive using joysticks.



In [ ]:

    
# Your code goes here!~