4.3: Custom Smart Controller

Goals:

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

1. Know the difference between x and y directions
2. Describe how the CoDrone EDU uses analog sticks for remote flight
3. Read analog stick values
4. Calibrate speed for analog sticks
5. Implement custom button functionality

Steps to Success:

1. Reading Analog Stick Values
2. Reading Analog Stick Values For Flight
3. Speed Limits
4. Button Functions

The CoDrone EDU controller has two analog joysticks that you have become familiar with over time. The right joystick controls pitch and roll, while the left joystick controls throttle and yaw by default. What if we wanted to make our own custom controller and swap the controls? First, we need to learn how to read joystick data from our remote in Python. Luckily, there are some functions that already exist that make that very easy to do!

First, in order to understand how the analog joysticks work, we need to imagine an x-y plane on top of them.

The X-axis moves to the left and right, while the Y-axis moves up and down. You may also notice that as X moves to the right of the origin, it becomes positive. Moving left of the origin, X becomes negative.

Try to imagine this plane on top of your analog sticks. As you move your analog stick to the right, the X-value for that stick will be a positive number. Moving the analog stick to the left will result in a negative number. Let’s write some code so we can see that happening:

from codrone_edu.drone import *

drone = Drone()
drone.pair()

while True:
    right_x = drone.get_right_joystick_x()
    right_y = drone.get_right_joystick_y()

    print("X value:", right_x, "Y value:", right_y)
    time.sleep(1)

When running this program, slowly move your analog stick to see your X and Y values changing. X and Y values will be between -100 and 100. When not moving the analog stick, the values will be 0.

Now that we know how to read our analog stick values, let’s use them for flying! You may remember from previous lessons that our flight movement commands (set_pitch, set_roll, etc.) take values between -100 and 100. This works perfectly for our analog stick functions, as they give values between -100 and 100. We simply need to assign our flight movement commands to the values our analog sticks are currently reading!

For this custom controller activity, we will be switching up the default configuration that you are familiar with. We will make the left analog stick control pitch and roll, while the right analog stick will control throttle and yaw. Let’s start with throttle so that we have a way to land the drone. If necessary, the controller’s emergency stop functionality will still work!

from codrone_edu.drone import *

drone = Drone()
drone.pair()

drone.takeoff()

while True:
    throttle = drone.get_right_joystick_y()
    drone.set_throttle(throttle)
    drone.move()

In this code, we are creating an infinite while loop that will continuously check our right analog stick’s Y value and assign its value to our throttle flight movement. If you move the left analog stick while in flight, you will notice that it doesn’t affect the drone at all. That’s only because we haven’t coded it yet!

See if you can code the rest of the flight movements on your own. The solution will be posted below:

from codrone_edu.drone import *

drone = Drone()
drone.pair()

drone.takeoff()

while True:
    pitch = drone.get_left_joystick_y()
    roll = drone.get_left_joystick_x()
    throttle = drone.get_right_joystick_y()
    yaw = drone.get_right_joystick_x()
    drone.set_pitch(pitch)
    drone.set_roll(roll)
    drone.set_throttle(throttle)
    drone.set_yaw(yaw)
    drone.move()

In the custom controller code above, the CoDrone EDU moves very quickly, since we are giving it the maximum speed value of 100. What if we wanted to put a speed limit on our drone to slow it down?

Using a conditional to check the speeds before they are sent to our flight commands would be the best way to do that. One condition we may check for is if the pitch value is above 60, then assign the pitch to be 60. We would also need to check for the negative value as well. Here is an example of how to implement a speed limit of 60:

from codrone_edu.drone import *

drone = Drone()
drone.pair()

drone.takeoff()

while True:
    pitch = drone.get_left_joystick_y()
    roll = drone.get_left_joystick_x()
    throttle = drone.get_right_joystick_y()
    yaw = drone.get_right_joystick_x()

    if pitch > 60:
        pitch = 60
    if pitch < -60:
        pitch = -60
    if roll > 60:
        roll = 60
    if roll < -60:
        roll = -60
    if throttle > 60:
        throttle = 60
    if throttle < -60:
        throttle = -60
    if yaw > 60:
        yaw = 60
    if yaw < -60:
        yaw = -60
    drone.set_pitch(pitch)
    drone.set_roll(roll)
    drone.set_throttle(throttle)
    drone.set_yaw(yaw)
    drone.move()

Now that our analog sticks are working, the last thing we need to add to our custom controller is our buttons! Let’s start by adding a takeoff button to our code. We will assign our takeoff to the L1 button. There are helpful button functions that you can use to check if a button has been pressed. The function we will use to check the L1 button is drone.l1_pressed(). This function will return true if L1 is pressed.

We will also make our own function called check_buttons() where we will assign all of our custom button functionality.

from codrone_edu.drone import *


def check_buttons():

    if drone.l1_pressed():
        drone.takeoff()
        print("takeoff")


drone = Drone()
drone.pair()

while True:
    check_buttons()
    pitch = drone.get_left_joystick_y()
    roll = drone.get_left_joystick_x()
    throttle = drone.get_right_joystick_y()
    yaw = drone.get_right_joystick_x()

    if pitch > 60:
        pitch = 60
    if pitch < -60:
        pitch = -60
    if roll > 60:
        roll = 60
    if roll < -60:
        roll = -60
    if throttle > 60:
        throttle = 60
    if throttle < -60:
        throttle = -60
    if yaw > 60:
        yaw = 60
    if yaw < -60:
        yaw = -60

    drone.set_pitch(pitch)
    drone.set_roll(roll)
    drone.set_throttle(throttle)
    drone.set_yaw(yaw)
    drone.move()

Now with this code we press L1 to takeoff. We are also able to land using our throttle and take off multiple times! Try adding some cool functionality to your buttons! You can add custom flight sequences, a flip, an LED light show, or anything else that you can think of. There will be a full sample code provided below but since this is a custom controller feel free to customize the code to whatever you want!

Full program:

from codrone_edu.drone import *


def check_buttons():

    if drone.l1_pressed():
        drone.takeoff()
        print("takeoff")
    elif drone.l2_pressed():
        drone.land()
        print("land")
    elif drone.r1_pressed():
        drone.flip()
        print("flip")


drone = Drone()
drone.pair()

while True:
    check_buttons()
    pitch = drone.get_left_joystick_y()
    roll = drone.get_left_joystick_x()
    throttle = drone.get_right_joystick_y()
    yaw = drone.get_right_joystick_x()

    if pitch > 60:
        pitch = 60
    if pitch < -60:
        pitch = -60
    if roll > 60:
        roll = 60
    if roll < -60:
        roll = -60
    if throttle > 60:
        throttle = 60
    if throttle < -60:
        throttle = -60
    if yaw > 60:
        yaw = 60
    if yaw < -60:
        yaw = -60

    drone.set_pitch(pitch)
    drone.set_roll(roll)
    drone.set_throttle(throttle)
    drone.set_yaw(yaw)
    drone.move()

Challenge 1: Flip the left and right joysticks! Make the left joystick control throttle and yaw and the right joystick control pitch and roll! This is the default remote controller analog stick configuration that you have used before.

Challenge 2: Make your own custom button or buttons. There are endless possibilities! You can code the LEDs to randomly change, or code the drone to do a flight sequence, you could even code a horn to honk while you are flying. You are encouraged to either choose one of these options or be creative and make your own custom button.

In this lesson, you were able to learn how to write a program for a custom controller by reading the button inputs of the CoDrone EDU’s controller. You were also able to read the inputs of the control sticks and calibrate your speed based off of those values.