Sams Teach Yourself Arduino Programming in 24 Hours (2015)

The area function retrieves the two parameters passed to the function, multiplies them, and then assigns the result to the result variable. The area function then uses the return statement to return the result back to the calling code. The setup function code uses the area function twice, with two different sets of values. Figure 10.3 shows the result you should see in your serial monitor after running the sketch.

FIGURE 10.3 The serial monitor output from running the sketch1003 code.

Now you have all the tools you need to create and run your own functions in your Arduino sketches. You’ll want to know about just a couple of other items to help make your life a little easier when working with functions. One of those is how to declare variables in your sketch, which the next section discusses.

Handling Variables in Functions

One thing that causes problems for beginning sketch writers is the scope of a variable. The scope is where the variable can be referenced within the sketch. Variables defined in functions can have a different scope than regular variables. That is, they can be hidden from the rest of the sketch.

Functions use two types of variables:

Global variables

Local variables

The following sections describe how to use both types of variables in your functions.

Defining Global Variables

Global variables are variables that are valid anywhere within the sketch code. If you define a global variable in the main section of your sketch, outside of the functions, you can retrieve its value inside any function in the sketch.

Let’s take a look at a simple example of defining a global variable:

const float pi = 3.14;

void setup() {
Serial.begin(9600);
float area;

Serial.print("The area of a circle with radius of 5 is ");
area = circleArea(5);
Serial.println(area);
Serial.print("The value of pi used for this calculation was ");
Serial.println(pi);
}

void loop() {
}

float circleArea(int radius) {
float result = pi * radius * radius;
return result;
}

Notice in the sketch, the pi variable is defined before any of the functions are defined. That makes it a global variable, and you can use it anywhere in the sketch code, including the setup and loop functions.

This can be a dangerous practice, however, especially if you intend to use your function in different sketches. The function code assumes the global variable exists, and will fail if it doesn’t.

Another danger of using global variables is if you use a global variable inside a function for a different purpose than what you use it outside of the function. If the function changes the global variable value and other functions don’t expect that, it might cause problems in your sketch. Here’s an example of this problem:

int temp, value;

void setup() {
int result;
Serial.begin(9600);
temp = 4;
value = 6;
result = func1();
Serial.print("The result is ");
Serial.println(result);
Serial.print("The value of temp is ");
Serial.println(temp);
}

void loop() {
}

int func1() {
temp = value + 5;
return temp * 2;
}

In this example, the temp and value variables are defined as global variables, and can be used in any function in the sketch. The temp variable was used in both the setup and func1 function, but for different purposes.

In the setup function, the temp variable is set to a static value of 4; however, it’s also used in the func1 function as a temporary variable, changing the value for a calculation. When the sketch cod returns back to the setup function, the value stored in the temp variable is now different. If you run this example in the serial monitor, you’ll get the following output:

The result is 22
The value of temp is 11

The change made to the temp variable in the func1 function affected the value in the entire sketch, not just in the func1 function. If you were expecting the temp variable to still be set to 4, you’d run into a problem with your code.

If you do need to use temporary variables inside a function, there’s a better way to do that than using global variables, as shown in the next section.

Declaring Local Variables

Instead of using global variables in functions, which run the risk of conflicting with other functions, you can use a local variable. You declare a local variable inside the function code itself, separate from the rest of the sketch code:

int func1() {
int calc;
calc = value + 5;
return calc * 2;
}

Once you declare the calc variable as a local variable inside the function, you can use it only inside the function where you declare it. If you try using it in another function, you’ll get an error:

sketch10test.ino: In function 'void setup()':
sketch10test:12: error: 'calc' was not declared in this scope

Another interesting feature of local variables is that you can override a global variable with a local variable:

int temp, value;

void setup() {
int result;
Serial.begin(9600);
temp = 4;
value = 6;
result = func1();
Serial.print("The result is ");
Serial.println(result);
Serial.print("The value of temp is ");
Serial.println(temp);
}

void loop() {
}

int func1() {
int temp;
temp = value + 5;
return temp * 2;
}

In this example, the temp variable is declared a second time in the func1 function as a local variable. That makes it separate from the temp variable that is declared as a global variable. Now if you run this sketch, you’ll get the following output:

The result is 22
The value of temp is 4

So, the original value assigned to the temp global variable remained intact after the function.