Variable Scope

Variable Scope

Variables in the C programming language, which Arduino uses, have a property called scope. This is in contrast to early versions of languages such as BASIC where every variable is a global variable.

A global variable is one that can be seen by every function in a program. Local variables are only visible to the function in which they are declared. In the Arduino environment, any variable declared outside of a function (e.g. setup(), loop(), etc. ), is a global variable.

When programs start to get larger and more complex, local variables are a useful way to insure that only one function has access to its own variables. This prevents programming errors when one function inadvertently modifies variables used by another function.

It is also sometimes handy to declare and initialize a variable inside a for loop. This creates a variable that can only be accessed from inside the for-loop brackets.

Example:

int gPWMval; // any function will see this variable void setup() { // ... } void loop() { int i; // "i" is only "visible" inside of "loop" float f; // "f" is only "visible" inside of "loop" // ... for (int j = 0; j <100; j++){ // variable j can only be accessed inside the for-loop brackets } }

Static

The static keyword is used to create variables that are visible to only one function. However unlike local variables that get created and destroyed every time a function is called, static variables persist beyond the function call, preserving their data between function calls.

Variables declared as static will only be created and initialized the first time a function is called.

Example

/* RandomWalk * RandomWalk wanders up and down randomly between two * endpoints. The maximum move in one loop is governed by * the parameter "stepsize". * A static variable is moved up and down a random amount. * This technique is also known as "pink noise" and "drunken walk". */
#define randomWalkLowRange -20 #define randomWalkHighRange 20 int stepsize; int thisTime; int total; void setup() { Serial.begin(9600); } void loop() { // tetst randomWalk function stepsize = 5; thisTime = randomWalk(stepsize); Serial.println(thisTime); delay(10); } int randomWalk(int moveSize){ static int place; // variable to store value in random walk - declared static so that it stores // values in between function calls, but no other functions can change its value place = place + (random(-moveSize, moveSize + 1)); if (place < randomWalkLowRange){ // check lower and upper limits place = place + (randomWalkLowRange - place); // reflect number back in positive direction } else if(place > randomWalkHighRange){ place = place - (place - randomWalkHighRange); // reflect number back in negative direction } return place; }

volatile keyword

volatile is a keyword known as a variable qualifier, it is usually used before the datatype of a variable, to modify the way in which the compiler and subsequent program treats the variable.

Declaring a variable volatile is a directive to the compiler. The compiler is software which translates your C/C++ code into the machine code, which are the real instructions for the Atmega chip in the Arduino.

Specifically, it directs the compiler to load the variable from RAM and not from a storage register, which is a temporary memory location where program variables are stored and manipulated. Under certain conditions, the value for a variable stored in registers can be inaccurate.

A variable should be declared volatile whenever its value can be changed by something beyond the control of the code section in which it appears, such as a concurrently executing thread. In the Arduino, the only place that this is likely to occur is in sections of code associated with interrupts, called an interrupt service routine.

Example

// toggles LED when interrupt pin changes state int pin = 13; volatile int state = LOW; void setup() { pinMode(pin, OUTPUT); attachInterrupt(0, blink, CHANGE); } void loop() { digitalWrite(pin, state); } void blink() { state = !state; } const keyword The const keyword stands for constant. It is a variable qualifier that modifies the behavior of the variable, making a variable "read-only". This means that the variable can be used just as any other variable of its type, but its value cannot be changed. You will get a compiler error if you try to assign a value to a const variable. Constants defined with the const keyword obey the rules of variable scoping that govern other variables. This, and the pitfalls of using #define, makes the const keyword a superior method for defining constants and is preferred over using #define. Example const float pi = 3.14; float x; // .... x = pi * 2; // it's fine to use consts in math pi = 7; // illegal - you can't write to (modify) a constant #define or const You can use either const or #define for creating numeric or string constants. For arrays, you will need to use const. In general const is preferred over #define for defining constants.