Parallax Propeller
Propeller C Tutorials
Tutorial #16- Memory Functions Can Share
Landstown High School Governor’s STEM & Technology Academy
Robotics Pathway
Tutorial #16- Memory Functions Can Share
(Updated 2013-08-08 for SimpleIDE 0.9.4 and its Learn folder's Simple Libraries and Examples)
So far, this Propeller C - Functions tutorial has used local variables declared inside of functions. There are advantages to
using local variables, since they only use memory temporarily while the function using the variable is executing. This can
be useful with microcontrollers, where memory is limited as compared to computers.
Sometimes it is necessary to have variables that more than one function can access and modify. These shared variables are
called global variables. The multicore Propeller can execute different functions with different cores (also called cogs) at
the same time. These functions operating in parallel can use global variables to exchange information (which we will do
in the next lesson).
The example program below uses a modified version of the adder function from the previous lesson, but with all local
variables replaced with global variables throughout the code.
How it Works
The adder function definition void adder(void) ; does not declare parameters or a return value.
Next, a, b, and c are declared as global variables. Since they are all the same type, int variables, they can be declared in
a single statement separated by commas.
Instead, a and b are assigned values in separate statements inside the main function, just before the adder function
call. The code jumps to the adder function, where the result of a + b is assigned to the global variable n.
Code execution then resumes on the next line in the main function, a print statement that displays the value of n.
Since a, b, and n were all declared before the first function, they were accessible to all the functions in the program.
So, there was no need to pass parameters or return values between functions.
Did You Know?
Declare & Initialize — In this example, a and b were first assigned values from within the main function. However,
that could have been done right in the original declaration, like this: int a = 96, b = 32, n;
Space vs. Speed — Global variables take more memory, but using them can make code execute faster in some
cases. Setting up and releasing memory for local variables takes a little bit of time. If your project uses lots and lots of
local variables, these bits of time can add up.
Scope — The terms local and global describe a variable's scope, the context in which the variable can be used validly in a
program.
BUG ALERT!
Do not put int (or any other variable type) in front of a global variable while using it inside a function! That
would create a local variable with the same name, but only that function would use it. It might not have the same
value as the same-named global function, and changes made to the local variable's value would not be stored in the
global same-name function.
Try This
Open a new Project and save it as “Memory Functions”.
Type in the code from below.
Click the Run with Terminal button, and verify that the main function displays the result that adder stores in
the global n variable.
/*
Global Exchange.c
Functions exchange information with global variables.
*/
#include "simpletools.h"
// Include simpletools
void adder(void);
// Forward declaration
int a, b, n;
// Global variables
int main()
{
a = 96;
b = 32;
adder();
print("n = %d\n", n);
}
// main function
void adder(void)
{
n = a + b;
}
// adder, no parameters or return
Save your file.
// Set values of a & b
// Call adder function
// Display result
// Use values of a & b to set n
Try This


Modify this program by creating a subtracter function that uses the global variables, and
add some code to your main function to test it.
Save your file as “Memory Functions 2”
Upload Assignment
 Upload the two files,
o Memory Functions,
o Memory Functions 2,
 To Edmodo- Assignment #16- Memory Functions can Share