-
void
The void keyword is used only in function declarations.
It indicates that the function is expected to return no
information to the function from which it was called.
Example
// actions are performed in the functions "setup" and "loop"
// but no information is reported to the larger program
void setup()
{
// ...
}
void loop()
{
// ...
}
-
boolean
A boolean holds one of two values, true or false. (Each boolean
variable occupies one byte of memory.)
Example
int LEDpin = 5; // LED on pin 5
int switchPin = 13; // momentary switch on 13, other side connected to ground
boolean running = false;
void setup()
{
pinMode(LEDpin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH); // turn on pullup resistor
}
void loop()
{
if (digitalRead(switchPin) == LOW)
{ // switch is pressed - pullup keeps pin high normally
delay(100); // delay to debounce switch
running = !running; // toggle running variable
digitalWrite(LEDpin, running) // indicate via LED
}
}
-
char
A data type that takes up 1 byte of memory that stores a character
value.
Character literals are written in single quotes, like this: 'A'
(for multiple characters - strings - use double quotes: "ABC").
Characters are stored as numbers however. You can see the specific
encoding in the ASCII chart.
This means that it is possible to do arithmetic on characters, in
which the ASCII value of the character is used (e.g. 'A' + 1 has
the value 66, since the ASCII value of the capital letter A is
65).
See Serial.println reference for more on how characters are
translated to numbers.
The char datatype is a signed type, meaning that it encodes
numbers from -128 to 127.
For an unsigned, one-byte (8 bit) data type, use the byte data
type.
Example
char myChar = 'A';
char myChar = 65; // both are equivalent
-
unsigned char
An unsigned data type that occupies 1 byte of memory. Same as the
byte datatype.
The unsigned char datatype encodes numbers from 0 to 255.
For consistency of Arduino programming style, the byte data type
is to be preferred.
Example
unsigned char myChar = 240;
-
byte
A byte stores an 8-bit unsigned number, from 0 to 255.
Example
byte b = B10010; // "B" is the binary formatter (B10010 = 18 decimal)
-
int
Integers are your primary data-type for number storage.
On the Arduino Uno (and other ATMega based boards) an int stores a
16-bit (2-byte) value. This yields a range of -32,768 to 32,767
(minimum value of -2^15 and a maximum value of (2^15) - 1).
On the Arduino Due, an int stores a 32-bit (4-byte) value. This
yields a range of -2,147,483,648 to 2,147,483,647 (minimum value
of -2^31 and a maximum value of (2^31) - 1).
int's store negative numbers with a technique called 2's
complement math.
The highest bit, sometimes referred to as the "sign" bit, flags
the number as a negative number.
The rest of the bits are inverted and 1 is added.
The Arduino takes care of dealing with negative numbers for you,
so that arithmetic operations work transparently in the expected
manner.
There can be an unexpected complication in dealing with the
bitshift right operator (>>) however.
Example
int ledPin = 13;
Syntax
int var = val;
var - your int variable name
val - the value you assign to that variable
Coding Tip
When variables are made to exceed their maximum capacity they
"roll over" back to their minimum capacity, note that this happens
in both directions.
Example for a 16-bit int:
int x;
x = -32768;
x = x - 1; // x now contains 32,767 - rolls over in neg. direction
x = 32767;
x = x + 1; // x now contains -32,768 - rolls over
-
unsigned int
On the Uno and other ATMEGA based boards, unsigned ints (unsigned
integers) are the same as ints in that they store a 2 byte value.
Instead of storing negative numbers however they only store
positive values, yielding a useful range of 0 to 65,535 (2^16) -
1).
The Due stores a 4 byte (32-bit) value, ranging from 0 to
4,294,967,295 (2^32 - 1).
The difference between unsigned ints and (signed) ints, lies in
the way the highest bit, sometimes refered to as the "sign" bit,
is interpreted.
In the Arduino int type (which is signed), if the high bit is a
"1", the number is interpreted as a negative number, and the other
15 bits are interpreted with 2's complement math.
Example
unsigned int ledPin = 13;
Syntax
unsigned int var = val;
var - your unsigned int variable name
val - the value you assign to that variable
Coding Tip
When variables are made to exceed their maximum capacity they
"roll over" back to their minimum capacity, note that this happens
in both directions.
Example for a 16-bit int:
unsigned int x
x = 0;
x = x - 1; // x now contains 65535 - rolls over in neg direction
x = x + 1; // x now contains 0 - rolls over
-
word
On the Uno and other ATMEGA based boards, a word stores a 16-bit
unsigned number.
On the Due and Zero instead it stores a 32-bit unsigned number.
Example
word w = 10000;
-
long
Long variables are extended size variables for number storage, and
store 32 bits (4 bytes), from -2,147,483,648 to 2,147,483,647.
If doing math with integers, at least one of the numbers must be
followed by an L, forcing it to be a long. See the Integer
Constants page for details.
Example
long speedOfLight = 186000L; // see the Integer Constants page for explanation of the 'L'
Syntax
long var = val;
var - the long variable name
val - the value assigned to the variable
-
unsigned long
Unsigned long variables are extended size variables for number
storage, and store 32 bits (4 bytes).
Unlike standard longs unsigned longs won't store negative numbers,
making their range from 0 to 4,294,967,295 (2^32 - 1).
Example
unsigned long time;
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print("Time: ");
time = millis();
//prints time since program started
Serial.println(time);
// wait a second so as not to send massive amounts of data
delay(1000);
}
Syntax
unsigned long var = val;
var - your long variable name
val - the value you assign to that variable
-
short
A short is a 16-bit data-type.
On all Arduinos (ATMega and ARM based) a short stores a 16-bit
(2-byte) value. This yields a range of -32,768 to 32,767 (minimum
value of -2^15 and a maximum value of (2^15) - 1).
Example
short ledPin = 13;
Syntax
short var = val;
var - your short variable name
val - the value you assign to that variable
-
float
Datatype for floating-point numbers, a number that has a decimal
point.
Floating-point numbers are often used to approximate analog and
continuous values because they have greater resolution than
integers.
Floating-point numbers can be as large as 3.4028235E+38 and as low
as -3.4028235E+38. They are stored as 32 bits (4 bytes) of
information.
Floats have only 6-7 decimal digits of precision.
That means the total number of digits, not the number to the right
of the decimal point.
Unlike other platforms, where you can get more precision by using
a double (e.g. up to 15 digits), on the Arduino, double is the
same size as float.
Floating point numbers are not exact, and may yield strange
results when compared.
For example 6.0 / 3.0 may not equal 2.0.
You should instead check that the absolute value of the difference
between the numbers is less than some small number.
Floating point math is also much slower than integer math in
performing calculations, so should be avoided if, for example, a
loop has to run at top speed for a critical timing function.
Programmers often go to some lengths to convert floating point
calculations to integer math to increase speed.
If doing math with floats, you need to add a decimal point,
otherwise it will be treated as an int.
See the Floating point constants page for details.
Example
float myfloat;
float sensorCalbrate = 1.117;
Syntax
float var = val;
var - your float variable name
val - the value you assign to that variable
Example Code
int x;
int y;
float z;
x = 1;
y = x / 2; // y now contains 0, ints can't hold fractions
z = (float)x / 2.0; // z now contains .5 (you have to use 2.0, not 2)
-
double
Double precision floating point number.
On the Uno and other ATMEGA based boards, this occupies 4 bytes.
That is, the double implementation is exactly the same as the
float, with no gain in precision.
On the Arduino Due, doubles have 8-byte (64 bit) precision.
Tip
Users who borrow code from other sources that includes double
variables may wish to examine the code to see if the implied
precision is different from that actually achieved on ATMEGA based
Arduinos.
-
string
Text strings can be represented in two ways.
you can use the String data type, which is part of the core as of
version 0019, or you can make a string out of an array of type
char and null-terminate it.
This page described the latter method.
For more details on the String object, which gives you more
functionality at the cost of more memory, see the String object
page.
Examples
All of the following are valid declarations for strings.
char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[ ] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";
Possibilities for declaring strings
Declare an array of chars without initializing it as in Str1
Declare an array of chars (with one extra char) and the compiler
will add the required null character, as in Str2
Explicitly add the null character, Str3
Initialize with a string constant in quotation marks; the compiler
will size the array to fit the string constant and a terminating
null character, Str4
Initialize the array with an explicit size and string constant,
Str5
Initialize the array, leaving extra space for a larger string,
Str6
Null termination
Generally, strings are terminated with a null character (ASCII
code 0).
This allows functions (like Serial.print()) to tell where the end
of a string is.
Otherwise, they would continue reading subsequent bytes of memory
that aren't actually part of the string.
This means that your string needs to have space for one more
character than the text you want it to contain.
That is why Str2 and Str5 need to be eight characters, even though
"arduino" is only seven - the last position is automatically
filled with a null character.
Str4 will be automatically sized to eight characters, one for the
extra null.
In Str3, we've explicitly included the null character (written
'\0') ourselves.
Note that it's possible to have a string without a final null
character (e.g. if you had specified the length of Str2 as seven
instead of eight).
This will break most functions that use strings, so you shouldn't
do it intentionally.
If you notice something behaving strangely (operating on
characters not in the string), however, this could be the problem.
Single quotes or double quotes?
Strings are always defined inside double quotes ("Abc") and
characters are always defined inside single quotes('A').
Wrapping long strings
You can wrap long strings like this:
char myString[] = "This is the first line"
" this is the second line"
" etcetera";
Arrays of strings
It is often convenient, when working with large amounts of text,
such as a project with an LCD display, to setup an array of
strings.
Because strings themselves are arrays, this is in actually an
example of a two-dimensional array.
In the code below, the asterisk after the datatype char "char*"
indicates that this is an array of "pointers".
All array names are actually pointers, so this is required to make
an array of arrays.
Pointers are one of the more esoteric parts of C for beginners to
understand, but it isn't necessary to understand pointers in
detail to use them effectively here.
Examples
char* myStrings[]={"This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5","This is string 6"};
void setup(){
Serial.begin(9600);
}
void loop(){
for (int i = 0; i < 6; i++){
Serial.println(myStrings[i]);
delay(500);
}
}
-
Arrays
An array is a collection of variables that are accessed with an
index number.
Arrays in the C programming language, on which Arduino is based,
can be complicated, but using simple arrays is relatively
straightforward.
Creating (Declaring) an Array
All of the methods below are valid ways to create (declare) an
array.
int myInts[6];
int myPins[] = {2, 4, 8, 3, 6};
int mySensVals[6] = {2, 4, -8, 3, 2};
char message[6] = "hello";
You can declare an array without initializing it as in myInts.
In myPins we declare an array without explicitly choosing a size.
The compiler counts the elements and creates an array of the
appropriate size.
Finally you can both initialize and size your array, as in
mySensVals.
Note that when declaring an array of type char, one more element
than your initialization is required, to hold the required null
character.
Accessing an Array
Arrays are zero indexed, that is, referring to the array
initialization above, the first element of the array is at index
0, hence
mySensVals[0] == 2, mySensVals[1] == 4,
and so forth.
It also means that in an array with ten elements, index nine is
the last element. Hence:
int myArray[10]={9,3,2,4,3,2,7,8,9,11};
// myArray[9] contains 11
// myArray[10] is invalid and contains random information (other memory address)
For this reason you should be careful in accessing arrays.
Accessing past the end of an array (using an index number greater
than your declared array size - 1) is reading from memory that is
in use for other purposes.
Reading from these locations is probably not going to do much
except yield invalid data.
Writing to random memory locations is definitely a bad idea and
can often lead to unhappy results such as crashes or program
malfunction.
This can also be a difficult bug to track down.
Unlike BASIC or JAVA, the C compiler does no checking to see if
array access is within legal bounds of the array size that you
have declared.
To assign a value to an array:
mySensVals[0] = 10;
To retrieve a value from an array:
x = mySensVals[4];
Arrays and FOR Loops
Arrays are often manipulated inside for loops, where the loop
counter is used as the index for each array element.
For example, to print the elements of an array over the serial
port, you could do something like this:
int i;
for (i = 0; i < 5; i = i + 1) {
Serial.println(myPins[i]);
}
Example
