2.6: Timers

Goals:

By the end of this lesson, I will be able to:

1. Explain how computers measure time
2. Describe what an epoch time is and how it impacts time calculations
3. Describe the calculations that occur when we add or subtract time
4. Store and use time values in variables and lists in a program
5. Use variables to store times and report the duration of flight movements and programs
6. Limit program time using timers

Steps to Success:

1. How Does the Timer Work?
2. Total Flight Timer
3. Movement Timer
4. Using Timers in a Function
5. Challenge 1: One Minute Code
6. Challenge 2: LED Flight Time Warning

Timers are everywhere so they might not seem like a big deal, but being able to use a timer in your program is an incredibly useful and powerful skill! This can help you keep better track of your flights and the movements within them.

You may remember back when we first learned how to import and create our drone that we discussed objects. We also mentioned that objects have properties and methods. Much like our drone object we create in each program is a virtual representation of our physical drone, we can create a timer object that keeps track of time much like a timer on your phone or watch would.

We have already used the time library before when we made our drone time.sleep(seconds). Now we will use it to check and the time at various points in our code and perform some simple math. Before we do this, let’s take a look at the time.time() function and see how it works and what value it gets:

For this activity, you will be programming a timer to keep track of your CoDrone EDU’s total flight, starting at takeoff and finishing with landing.

After importing the CoDrone EDU and time libraries, creating the drone object, and pairing, create a variable to store the drone’s starting time (we called ours  start_time ). Have your drone take off and land, and then create another variable to store the drone’s ending time (we called ours  end_time ).

To get the total time of your drone’s flight, create a variable that will subtract start_time from end_time. We called ours  elapsed_time . Finally, use a print command to have your program print the elapsed time in seconds.

Once you have tried this out, add hovering and then some flight movements into your program. What changes do you notice?

Your code should look something like this:

from codrone_edu.drone import *

import time


drone = Drone()

drone.pair()

start_time = time.time()

drone.takeoff()

drone.land()

end_time = time.time()


elapsed_time = end_time - start_time

print(elapsed_time)
drone.close()

What if you wanted to check how long one section in your program took, like how long your drone takes to fly in one square, or if pitching forward for 2 seconds actually takes 2 seconds? There’s a way to do that, and it just involves moving some timers around in your program!

For this exercise, we will pretend that we are programming a movie videography drone. The director wants a 360 degree continuous shot around the two actors for an epic final scene! They need at least 30 seconds of video to cut into the movie. For this program, we will create a loop that lasts 30 seconds using a time and fly in a circle around the actors.

After importing the CoDrone EDU, Sequence and time libraries, creating the drone object, and pairing, have your drone take off.

Next, we need create the variables for the loop. We will create a start_time that will capture the time right before the loop. We will also create an end_time and assign it the start_time variable value + 30 seconds for the required flight time:

from codrone_edu.drone import *
import time

drone = Drone()
drone.pair()
drone.takeoff()

start_time = time.time()
end_time= start_time + 30

Now, we need to create the loop. To do this, we will compare the start_time to the end_time and as long as it is less than the end time, we keep running the circle.

drone.set_pitch(50)
drone.set_yaw(50)
while start_time < end_time:
    drone.move()
    start_time = time.time() #update the time once the sequence is done

drone.land()

We have to update the start_time after each sequence or it would end up creating an infinite loop. Can you figure out why?

Now, have your drone land. To check if our flight time was enough, add a line that prints out the difference between start time and end time. Did we fly long enough? Was it exactly 30 seconds? If the time wasn’t exact, why do you think this is the case?

Creating multiple variables to time one thing can be a lot. In cases when you want to time one movement, you can create a function instead! This will run a timer for the  move() function for however many seconds you put in the parameters.

After importing the CoDrone EDU and time libraries, creating the drone object, and pairing, define a function (we called ours  fly() ) and put seconds in the parameters. Next, create a variable to store the drone’s starting time. Create a while loop so that if the time minus the start time is less than the seconds in the parameters, the drone will move.

Next, have your drone take off and set the pitch to 30. Include the fly() function and set the parameters to 2 seconds, and then have the drone land.

Play around with the time in the parameters. What happens? Does increasing or decreasing the pitch have an impact on the time?

Your code should look something like this:

from codrone_edu.drone import *
import time


drone = Drone()
drone.pair()

# -------- function definition ---------


def fly(seconds):

    start_time = time.time()

    while time.time() - start_time < seconds:

        drone.move()

# --------------------------------------


drone.takeoff()
drone.set_pitch(30)
fly(2)
drone.land()

drone.close()

Fit as much flight movement as you can into one minute exactly (according to the  elapsed_time variable in your program)!

Rules:

• You must include at least one pitch, one throttle, one yaw, and one roll.
• Any flight movement, including hovering or delaying, can only last for 3 seconds.
• The same movement cannot be used in consecutive order, whether that is one after the other or in a loop (so don’t loop pitching forward for 3 seconds 20 times).
• Takeoff and landing are included in the one minute.

For this challenge, create a program that takes a user input and sets a timer to wait for an amount of time equal to that input. After the timer has finished, have your drone take off and act as an alarm clock, changing LED colors and playing sounds. In order to complete this challenge, your program must have the following:

• A user input prompt asking for the amount of time for the timer in seconds
• The input must be converted into an integer to be used for the timer
• You must have at least two different LED colors and three different sounds after the timer has finished

In this lesson, you learned about the time Python library! You learned how your computer measures time, what the epoch is, and how to use the time library to calculate the elapsed time in a program.