You can name a variable any word that is not already one of the keywords in Arduino. Avoid beginning variable names with numeral characters.

Programmers should consider the size of the numbers they wish to store in choosing variable types. Variables will roll over when the value stored exceeds the space assigned to store it. See below for an example.

Variable Rollover

Using Variables

Once variables have been declared, they are used by setting the variable equal to the value one wishes to store with the assignment operator (single equal sign). The assignment operator tells the program to put whatever is on the right side of the equal sign into the variable on the left side.

inputVariable1 = 7;             // sets the variable named inputVariable1 to 7
inputVariable2 = analogRead(2); // sets the variable named inputVariable2 to the 
                                // (digitized) input voltage read from analog pin #2

Variable Rollover

Programmers should consider the size of the numbers they wish to store in choosing variable types. Variables will roll over when the value stored exceeds the space assigned to store it. See below for an example.

[@ int calibrationVal = 17; // declare calibrationVal and set initial value

Programmers should consider the size of the numbers they wish to store in choosing variable types. Variables will roll over? when the value stored exceeds the space assigned to store it. See below for an example.

Programmers should consider the size of the numbers they wish to store in choosing variable types. Variables will roll over when the value stored exceeds the space assigned to store it. See below for an example.

Variable Scope

Another important choice that programmers face is where to declare variables. The specific place that variables are declared influences how various functions in a program will see the variable. This is called variable scope.

Initializing Variables

Variables may be initialized (assigned a starting value) when they are declared or not. It is always good programming practice however to double check that a variable has valid data in it, before it is accessed for some other purpose.

Example:

 int calibrationVal = 17;  // declare and set initial value

Variable Rollover

When variables are made to exceed their maximum capacity they "roll over" back to their minimum capacity, note that this happens in both directions.

   int x
   x = -32,768;
   x = x - 1;       // x now contains 32,767 - rolls over in neg. direction

   x = 32,767;
   x = x + 1;       // x now contains -32,768 - rolls over

Programmers should consider the size of the numbers they wish to store in choosing variable types. Variables will roll over when the value stored exceeds the space assigned to store it. For example a byte

Another important choice that programmers face is where to declare variables.

 the specific place that variables are declared influences how the program will see the variable. This is called variable scope.

Variable Scope

• Variable Scope

   char errorMessage = {"choose another option"}; // see string @]

   unsigned long speedOfLight = 186000UL;
   char errorMessage = {"choose another option"}; // see string 

Examples

[@ int lightSensVal;

   char currentLetter;
   long speedOfLight = 186000;
   char 

This example shows all three useful operations with variables. It tests the variable ( if (inputVariable2 < 100) ), it sets the variable if it passes the test ( inputVariable2 = 100 ), and it uses the value of the variable as an input parameter to the delay() function ( delay(inputVariable2) )

A variable is a way of naming and storing a value for later use by the program, such as data from a sensor or an intermediate value used in a calculation.

Variables may be initialized (assigned a starting value) when they are declared or not. It is always good programming practice however to make sure that a variable has valid data in it, before it is accessed for some other purpose.

Once a variable has been set (assigned a value), you can test its value to see if it meets certain conditions, or you can use its value directly. For instance, the following code tests whether the inputVariable2 is less than 100, then sets a delay based on inputVariable2 which is a minimum of 100:

Some variable types

Once a variable has been set (assigned a value), you can test its value to see if it meets certain conditions, or you can use it's value directly. For instance, the following code tests whether the inputVariable2 is less than 100, then sets a delay based on inputVariable2 which is a minimum of 100:

if (inputVariable2 < 100)

  inputVariable2 = 100;

delay(inputVariable2);@]

This example shows all three useful operations with variables. It tests the variable ( if (inputVariable2 < 100) ), it sets the variable if it passes the test ( inputVariable2 = 100 ), and it uses the value of the variable as an input to the delay() function ( delay(inputVariable2) )

Once variables have been declared, they are used by setting the variable equal to the value one wishes to store with the assignment operator (single equal sign). The assignment operator tells the program to put whatever is on the right side of the equal sign into the variable on the left side.

Example

Once a variable has been set (or re-set), you can test its value to see if it meets certain conditions, or you can use it's value directly. For instance, the following code tests whether the inputVariable2 is less than 100, then sets a delay based on inputVariable2 which is a minimum of 100:

Before they are used, all variables have to be declared. Declaring a variable means defining its type, and optionally, setting an initial value (initializing the variable). Variables do not have to be initialized (assigned a value) when they are declared, but it is often useful.

Programmers should consider the size of the numbers they wish to store in choosing variable types. Also the specific place that variables are declared influences how the program will see the variable. This is called variable scope.

[@

@]

inputVariable2 = analogRead(2); // sets the variable named inputVariable2 to the

                                // (digitized) input voltage read from analog pin #2@]

inputVariable1 = 7; // sets the variable named inputVariable1 to 7 inputVariable2 = analogRead(2); // set the variable named inputVariable2 to the (digitized) input voltage read from analog pin #2@]

Declaring Variables

Before they are used, all variables have to be declared. Declaring a variable means defining its type, and optionally, setting an initial value (initializing the variable). Variables do not have to be intialized (assigned a value) when they are declared, but it is often useful.

Programmers should consider the size of the numbers they wish to store in choosing variable types. Also the specific place that variables are declared influences how the program will 'see' the variable. This is called variable scope.

int inputVariable1; int inputVariable2 = 0; // both are correct

Using Variables

Once variables have been declared, they are used by setting the variable equal to the value one wishes to store with the assignment operator (single equal sign). The assignment operator tells the program to put whatever is on the left side of the equal sign into the variable on the right side.

inputVariable1 = 7; // sets the inputVariable1 to 7 inputVariable1 = analogRead(2); // set the variable to the (digitized) input voltage of analog pin #2@]

Variables are used by setting them equal to the value one wishes to store with the assignment operator (single equal sign). The following code declares a variable inputVariable, and then sets it equal to the value at analog pin #2:

You set a variable by making it equal to the value you want to store. The following code declares a variable inputVariable, and then sets it equal to the value at analog pin #2:

inputVariable is the variable itself. The first line declares that it will contain an int (short for integer.) The second line sets inputVariable to the value at analog pin #2. This makes the value of pin #2 accessible elsewhere in the code.

A value is stored in a variable by assigning a value to it with the equal sign [=] ( single equal sign more formally called the assignment operator.

The following code declares a variable inputVariable, and then sets it equal to the value at analog pin #2:

inputVariable is the variable itself. The first line declares that it will contain an int (short for integer.) The second line sets inputVariable to the value at analog pin #2. This makes the value of pin #2 accessible elsewhere in the code.

You can name a variable any word that is not already one of the keywords? in Arduino. Avoid beginning variable names with numeral characters.

• byte

All variables have to be declared before they are used. Declaring a variable means defining its type, and optionally, setting an initial value (initializing the variable). In the above example, the statement

  inputVariable = 100;

delay(inputVariable);@]

• unsigned int

• unsigned long

• unsigned int?

• unsigned long
• float
• double

int inputVariable = 0; // declares the variable; this only needs to be done once inputVariable = analogRead(2); // set the variable to the input of analog pin #2@]

Variables

Once a variable has been set (or re-set), you can test its value to see if it meets certain conditions, or you can use it's value directly. For instance, the following code tests whether the inputVariable is less than 100, then sets a delay based on inputVariable which is a minimum of 100:

inputVariable = analogRead(2); # Set the variable to the input of analog pin #2@]

A variable is a way of naming and storing a value for later use by the program, such as data from a analog pin set to input. (See pinMode for more on setting pins to input or output.)

inputVariable is the variable itself. The first line declares that it will contain an int (short for integer.) The second line sets inputVariable to the value at analog pin #2. This makes the value of pin #2 accessible elsewhere in the code.

Once a variable has been set (or re-set), you can test it's value to see if it meets certain conditions, or you can use it's value directly. For instance, the following code tests whether the inputVariable (from analog pin #2) is less than 100, then sets a delay based on inputVariable which is a minimum of 100:

if (inputVariable < 100)

  inputVariable = 100

}

delay(inputVariable)@]

This example shows all three useful operations with variables. It tests the variable ( if (inputVariable < 100) ), it sets the variable if it passes the test ( inputVariable = 100 ), and it uses the value of the variable as an input to the delay() function ( delay(inputVariable) )

Style Note: You should give your variables descriptive names, so as to make your code more readable. Variable names like tiltSensor or pushButton help you (and anyone else reading your code) understand what the variable represents. Variable names like var or value, on the other hand, do little to make your code readable.

int inputVariable = 0; # Declares the variable; this only needs to be done once inputVariable = analogRead(2); # Set the variable@]

You set a variable by making it equal to the value you want to store. The following code declares a variable inputVariable, and then sets it equal to the value at analog pin #2:

A variable is a way of naming and storing a value for later use by the program. An example of , like data from a analog pin set to input. (See pinMode for more on setting pins to input or output.)

 You set a variable by making it equal to the value you want to store. The following code declares a variable inputVariable, and then sets it equal to the value at analog pin #2:

int inputVariable = 0; # This declares the variable, declaration only needs to be done once inputVariable = analogRead(2); # This sets the variable@]

inputVariable is the variable itself. The first line declares that it will contain an int, which is to say a whole number. The second line sets inputVariable to the value at analog pin #2. This makes the value of pin #2 accessible elsewhere in the code. For instance, the following code tests whether the value at analog pin #2 is greater than 0:

inputVariable = analogRead(2);@]

}@]

You should give your variables descriptive names, so as to make your code more readable. Variable names like tiltSensor or pushButton help you (and anyone else reading your code) understand what the variable represents. Variable names like var or value do little to make your code readable.

A variable is a way of giving a name to the stored value. You set a variable by making it equal to the value you want to store. The following code declares a variable inputVariable, and then sets it equal to the value at analog pin #2:

int inputVariable = 0;

inputVariable is the variable itself. The first line declares that it will contain an int, which is to say a whole number. The second line sets inputVariable to the value at analog pin #2. This makes the value of pin #2 accessible elsewhere in the code. For instance, the following code tests whether the value of inputVariable is greater than 0:

You can name a variable any word that is not already one of the keywords? in Arduino.

All variables have to be declared before they are used. To declare a variable implies to define its type, and an initial value.

[@

@]

[@

@]

int inputVariable;

if (inputVariable > 0) {

  # do something here

int inputVariable;\\

if (inputVariable > 0)
{
# do something here\\

A variable is a way of giving a name to the stored value. You set a variable by making it equal to the value you want to store. The following code sets inputVariable equal to the value at analog pin #2:

int inputVariable; inputVariable = analogRead(2);

input_variable is the variable itself. The first line declares that it will contain an int, which is to say a whole number. The second line sets inputVariable to the value at analog pin #2. This makes the value of pin #2 accessible elsewhere in the code. For instance, the following code tests whether the value of inputVariable is greater than 0:

if (inputVariable > 0) {

  # do something here

}

You give your variables descriptive names, so as to make your code more readable. Variable names like tiltSensor or pushButton help you (and anyone else reading your code) understand what the variable represents. Variable names like var or value do little to make your code readable.

You can choose any word that is not already existing in the language. The pre-defined words in the language are also called keywords. Examples of keywords are: digitalRead, pinMode, or setup.

Again it is possible to choose completely random names like tomato or I_love_Sushi but this will make much more complicated for other people to read your code and it is not recommended. Use variable names that describe what you're using them for, like sensorValue or switchState.

Variable Declaration

Variables have to be declared before they are used. To declare a variable implies to define its type, and an initial value.

int val = 0;

A variable is a way of giving a name to the stored value. You set a variable by making it equal to the value you want to store. The following code sets input_variable equal to the value at analog pin #2:

input_variable is the variable itself; it makes the value at analog pin #2 accessible elsewhere in the code. For instance, the following code tests whether the value of input_variable is The name of the variable is val in this case, but we could have chosen anything else like e.g. inputPin or sensorA.

A variable is a way of giving a name to the stored value. You set a variable by making it equal to the value you want to store. The following code sets input_variable equal to the value at analog pin #2.:

input_variable = analogRead(2);

input_variable is what's called a variable. It is a container for data inside the memory of Arduino. The name of the variable is val in this case, but we could have chosen anything else like e.g. inputPin or sensorA.

Variables are expressions that store values, like sensor reading and storing input from a analog pin set to input. (See pinMode for more on setting pins to input or output.)

Variables

val is what's called a variable. It is a container for data inside the memory of Arduino. The name of the variable is val in this case, but we could have chosen anything else like e.g. inputPin or sensorA.

Again it is possible to choose completely random names like tomato or I_love_Sushi but this will make much more complicated for other people to read your code and it is not recommended. Use variable names that describe what you're using them for, like sensorValue or switchState.

The previous statement informs that the variable val is of the type int and that its initial value is zero.

• int
• char

Reference Home

Variables

Variables are expressions that can be used in programs to store values, like e.g. sensor reading from an analog pin.

val = analogRead(2);

val is what we call a variable. It is a container for data inside the memory of Arduino. The name of the variable is val in this case, but we could have chosen anything else like e.g. inputPin or sensorA.

You can choose any word that is not already existing in the language. The pre-defined words in the language are also called keywords. Examples of keywords are: digitalRead, pinMode, or setup.

Again it is possible to choose completely random names like tomato or I_love_Sushi but this will make much more complicated for other people to read your code and it is not recommended.

Variable Declaration

Variables have to be declared before they are used. To declare a variable implies to define its type, and an initial value.

int val = 0;

The previous statement informs that the variable val is of the type Integer and that its initial value is zero.

Possible types for variables are:

• Integer?

• Char?