Void Functions

Step 1

What is a function?

Quick review of functions from the pairing lesson: they’re a way to save time and energy by storing commonly used blocks of code into one named set. For example, if you want to connect to the last CoDrone you paired with, you can type in at least six lines of code, or you can just use the function CoDrone.pair().

Step 2

Creating a function

There are two parts to writing a function: the call and the declaration.

You’ve already seen and used the call before — it’s just using the function! For example, if you wanted to use the function to connect to the previously paired CoDrone, you would use this for the call:

CoDrone.pair()

Unless you’ve already written your own functions before, you probably haven’t used declarations yet. A declaration tells the program what you want the function to be able to do. This is what that usually looks like:

void functionName(inputs) {
  statements
}

This is what’s going on here:

We’ll be talking about this in a later lesson, but some functions will return a certain value. Nothing will be returning in this lesson, so you can write void instead.
functionName is the name of the function.
Inputs are what you want to receive. This could be a duration of time, the LEDs that should light up, the drone to connect to, or in some cases, like with CoDrone.move(), nothing at all.
Statements are the code that will run when the function is called.

Step 3

Creating a function: GoForward()

Here’s an example of how to make a function.

To make your CoDrone fly forward for 2 seconds, you would write:

CoDrone.setPitch(70);
CoDrone.setThrottle(0);
CoDrone.move(2);

That would work if you just want your CoDrone to go forward once. What happens if you’re doing a program where you want your CoDrone to look like it’s going up a flight of stairs? You could create a function called goForward() instead!

void goForward() {  
    CoDrone.setPitch(70);
    CoDrone.move(2);
}

Now, when you use void goForward(), your CoDrone will always pitch forward at 70 for 2 seconds.

#include <CoDrone.h>

void setup() {  
    CoDrone.begin(115200);  
    CoDrone.pair();  
    delay(200);  //waits 200 milliseconds or 0.2 second

    CoDrone.setThrottle(70);
    CoDrone.move(2); 
 
    goForward();  

    CoDrone.setThrottle(60);
    CoDrone.move(2); 

    goForward();

    CoDrone.setThrottle(50);
    CoDrone.move(2); 

    goForward();
    

    CoDrone.land();
} 

void loop() {
}

void goForward() {  
    CoDrone.setPitch(70);
    CoDrone.move(2);
}

Important for you to know: when you write a function, it should be outside of void setup() and void loop(). Unlike variables, functions do not need to be declared at the beginning of the program, so we put ours at the end.

Step 4

Declaring functions with inputs

One of the good things about functions is that they can accept inputs. For example, if you wanted to turn LED 11 on your Smart Inventor Board on, you could write this:

digitalWrite(11,1)

Don’t forget, 1 is the same thing as HIGH, which is on! But if you changed your mind and wanted to turn LED 14 on instead, you would just write this:

digitalWrite(14,1);

The only thing that changed was the pin number. The function is the same because it’s performing (almost) the same operation.

To declare, or write, a function that is able to do this, you would need to include variables that are only used within the function:

void myFunction(int x, int y) {
}

Once those variables are declared, you can use them inside the function!

void myFunction(int x, int y) {
  Serial.print(x);
  Serial.print("  ");
  Serial.println(y);
}

If you want three (or more!) inputs, you can add them into the variable declaration.

void myFunction( int x, int y, int z, int namedWhateverYouLike) {
}

Step 5

Calling functions with inputs

When you call a function, make sure that you include the right number of values. You also need to make sure that you put your values in the right place. For example, if you created two variables in your function, you could use 5 and 9, and they would show up in that order. If you wanted to switch the order, you would have to write 9 and 5 in your program instead.

Try this program out in Arduino’s serial monitor to see what we mean!

void setup() {  
    Serial.begin(9600);
} 

void loop() {  
    MyFunction(5, 9);
} 

void MyFunction(int x, int y) {  
    Serial.print(x);  
    Serial.print("  ");      
    Serial.println(y);
}

Another example! What happens if you have the function below that has a delay of two seconds, but realize that sometimes, you might want your CoDrone to go forward to three seconds?

void GoForward() {  
    CoDrone.setPitch(70);
    CoDrone.setThrottle(0);
    CoDrone.move(2);
}

What you can do instead of going back and changing your milliseconds every. single. time. is create a variable that will store your time (we called ours duration).

void GoForward(int duration){  
    CoDrone.setPitch(70);
    CoDrone.setThrottle(0);
    CoDrone.move(duration);
}

When you call the function, you can use whatever time duration you want in the parentheses!

GoForward(3);

Try this code on your own to see how it works.

#include <CoDrone.h> 

void setup() {  
    CoDrone.begin(115200);  
    CoDrone.pair();  
    delay(200);    //waits 200 milliseconds or 0.2 second

    CoDrone.takeoff();
 
    CoDrone.setThrottle(70);
    CoDrone.move(2);   

    GoForward(3000);  

    CoDrone.setThrottle(60);
    CoDrone.move(2);  

    GoForward(2000);

    CoDrone.setThrottle(50);
    CoDrone.move(2);

    GoForward(1000);

    CoDrone.land();
} 

void loop() { 
} 

void GoForward(int duration) { 
    CoDrone.setPitch(70);
    CoDrone.setThrottle(0);
    CoDrone.move(duration);
}

Step 6

LEDs made easy

If you wanted to turn your remote control’s LEDs on, you would have to use copy and paste a lot, or you’d have to be a really fast typer.

digitalWrite(11, 1);
digitalWrite(12, 1);
digitalWrite(13, 1);
digitalWrite(14, 1);
digitalWrite(15, 1);
digitalWrite(16, 1);
digitalWrite(17, 1);
digitalWrite(18, 1);

To make your life easier, you can turn this into a function!

void LEDs(int p11, int p12, int p13, int p14, int p15, int p16, int p17, int p18) {
  digitalWrite(11, p11);
  digitalWrite(12, p11);
  digitalWrite(13, p13);
  digitalWrite(14, p14);
  digitalWrite(15, p15);
  digitalWrite(16, p16);
  digitalWrite(17, p17);
  digitalWrite(18, p18);
}

Now you can just write the function and a bunch of numbers. If you wanted all of your LEDs on at one time, you could write this:

LEDs( 1, 1, 1, 1, 1, 1, 1, 1);

If you wanted half of them off and half of them on, you could write this:

LEDs( 1, 0, 1, 0, 1, 0, 1, 0);

If you want to use high and low instead, you can do that too!

LEDs(HIGH, LOW, HIGH, LOW, HIGH, LOW, HIGH, LOW);

Step 7

Flight directions function

Another set of commands that you use a lot is flight commands! With this block of code, your CoDrone would fly up and forwards.

CoDrone.setThrottle(60);
CoDrone.setPitch(40);
CoDrone.move();

To make this easier, you can create a function (we called ours Maneuver) and include all of the flight directions as variables. We know this seems complicated with a lot of typing now, but we promise it will make everything easier!

void Maneuver (int throttle, int roll, int pitch, int yaw) {  
    CoDrone.setThrottle(throttle);
    CoDrone.setRoll(roll);
    CoDrone.setPitch(pitch);
    CoDrone.setYaw(yaw); 
    CoDrone.move();
}

Once you include that, you can just use the numbers you need! If you wanted to use the same throttle and pitch from the example, it would look like this:

Maneuver(60, 40, 0, 0);

This is what it would look like in a program. Try it out on your own to see what happens!

#include <CoDrone.h> 

int StartFlag;
unsigned long StartTime; 

void setup() {  
    CoDrone.begin(115200);  
    CoDrone.pair();

    CoDrone.takeoff();
    CoDrone.move(2);
} 

void loop() {  
    byte bt1 = digitalRead(11);  
    byte bt4 = digitalRead(14);  
    byte bt8 = digitalRead(18);   

    if (bt8) {    
        StartFlag = 1;    
        StartTime = millis();  
    }   

    if (StartFlag == 1) {    
        if (millis() - StartTime < 2000) {      
            Maneuver(30, 0, 0, 0);    
        }    
        else if (millis() - StartTime < 5000) {      
            Maneuver(0, 0, 70, 0);    
        }    
        else {      
            CoDrone.land();       
            StartFlag = 0;    
        }  
    }   

    if ( bt1) {    
        CoDrone.emergencyStop();    
        StartFlag = 0;  
        }
    } 

  void Maneuver (int throttle, int roll, int pitch, int yaw) {  
    CoDrone.setThrottle(throttle);
    CoDrone.setRoll(roll);
    CoDrone.setPitch(pitch);
    CoDrone.setYaw(yaw); 
    CoDrone.move();
}

Step 8

Challenge

Challenge: Function Fiesta

Create CoDrone codes for three functions!

Rules:

One of the functions should include the flight directions (you just learned how to do this!).
Another function should control the CoDrone’s LEDs.
The third function is your choice!

This lesson works with:

Grade level:

Approx. time required:

CSTA

CCSS