4.4: Height

Goals:

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

1. Explain how the get_height() function abstracts the calculations I performed in the previous lesson
2. Explain how the drone measures height using barometer values
3. Check the drone’s height at various points in a program
4. Store the drone’s height as a variable and use it to make decisions
5. Identify variances or differences from the drone’s measured height versus its actual height
6. Explain why the drone’s program height may vary from reality

Steps to Success:

1. How High in the Sky?
2. Takeoff Height
3. Measuring Height in a Loop
4. Challenge 1: Fact Checker
5. Challenge 2: Flight Ceiling

Quick review: the barometer in your CoDrone Mini measures the surrounding air pressure. Generally, air pressure is greatest at sea level and then decreases as the altitude, or height, increases.

With your CoDrone Mini, you will be using the barometer to check sea level and then the altitude from the floor. This can be done once or multiple times in one program.

The function that you will be using to measure the height of your drone from the floor is  get_height() . This function checks the barometer while on the ground and then the value in the air and returns a height in centimeters. Very similar to what you did in the challenge from the previous lesson!

Try out this example program to see what it looks like in action! 

import CoDrone_mini

drone = CoDrone_mini.CoDrone()

drone.pair()


drone.takeoff()

drone.hover(3)

height = drone.get_height()

print(height)

drone.land()

drone.close()

Get the height of your drone before takeoff, while it’s in the air, and after it lands!

After importing the library, creating the drone object, and pairing with CoDrone Mini, create a variable that will get the drone’s height on the floor. We named ours  begin_height . Write a takeoff command after it.

Next, create another variable that will get the drone’s height while it is in the air (ours is  mid_height ) and include a land command after that. Create one more variable that will get the drone’s height after landing.

Finally, write three print commands that will display the drone’s heights at each part of its flight.

This is what your program should look like:

import CoDrone_mini

drone = CoDrone_mini.CoDrone()

drone.pair()


begin_height = drone.get_height()

drone.takeoff()

mid_height = drone.get_height()

drone.land()

end_height = drone.get_height()


print("Before taking off: ", begin_height)

print("After taking off: ", mid_height)

print("Landed: ", end_height)

drone.close()

Once you’ve seen this, play around with your program! What happens if you move the print statements around or add more flight movements?

The  get_height() function can be used in a loop to measure one height after the other. In this program, you’re going to measure the altitude of your drone as it keeps throttling up.

To start, import the CoDrone Mini and time libraries, create the drone object, and then pair to CoDrone Mini. Next, create a variable called  throttle and set it to 20, which is its power percentage. Then reset your drone’s barometer.

Include a print command that will print the drone’s initial height, which should be the floor. Next, create a list called  height_data . This will store all of the altitudes that your drone reaches.

Set up a for loop that repeats three times. Your drone should takeoff and throttle up for 1.5 seconds at the percentage stored in the throttle variable, which starts out at 20. The  get_height() function should then get the altitude and add that value to the  height_data() list. The drone should then land and then sleep for 5 seconds, which will give you time to reposition it if needed. Next, a value of 10 should be added to throttle.

After the loop, include a command to print the data that was stored in the height_data() list. Does the data look like what you expected?

Your program should look something like this:

import CoDrone_mini

import time

drone = CoDrone_mini.CoDrone()

drone.pair()


throttle = 20

drone.reset_sensor()

drone.set_trim(25,15) # set your own trim values

time.sleep(1) # to avoid skipping takeoff()

print("Initial: ", drone.get_height())

height_data = []

for i in range(3):

    drone.takeoff()

    drone.set_throttle(throttle)

    drone.move(1.5)

    height_data.append(drone.get_height())

    drone.land()

    time.sleep(5) # gives time to reposition your drone on the ground

    throttle = throttle + 10

print(height_data)

drone.close()

Have CoDrone Mini fly to three different places in the room you’re in, like to the top of a closet, the top of a bookcase, and the top of a chair. Include print commands so you know how many centimeters the altitude is at each location. Next, get a meter stick or measuring tape and see if the height of each place matches up with what was printed out!

Commercial and recreational aircraft often operate under a “service ceiling”, this is the maximum supported altitude for the aircraft. For example, our drone’s typically aren’t flying as high as commercial airlines. This is because each aircraft’s design determines how high up it can actually fly. For this challenge, we want to create a service ceiling for our drone in the program. To do this, follow the steps below:

1. Create a variable called SERVICE_CEILING and set it to a value of your choosing in centimeters. We use all caps, because this is a CONSTANT, meaning its value should not change during a program.
2. Define a function that has no parameters but checks the height against the SERVICE_CEILING constant. If the drone is above the ceiling, it should blink the LED red and land the drone. If not, it should continue on in the program.
3. Write some flight commands that will eventually force the drone close to or above the SERVICE_CEILING to test your limiting of the drone’s flight.