Constants¶
Constants are like predefined variables, whose values can’t change. They are used to make the programs easier to read and modify. This page describes the most commonly used constants.
Contents
Boolean Constants¶
There are two constants used to represent truth and falsity: true
,
and false
.
true¶
true
is the true bool
value. As an integer, true
is often
said to be 1. This is correct in the sense that true
evaluates to
1 as an integer. However, any integer which is non-zero is true
as a bool. So -1, 2 and -200 are all
“true”, in the sense that these numbers are treated the same as
true
in a boolean context.
Note that the true
and false
constants are typed in lowercase;
unlike e.g. HIGH
, LOW
, INPUT
, and OUTPUT
(which are
described below).
Pin Levels: HIGH and LOW¶
When reading or writing to a digital pin there are only two possible
values a pin can be set to: HIGH
and LOW
.
HIGH¶
The meaning of HIGH
(in reference to a pin) is somewhat different
depending on whether the pin is set to INPUT
or OUTPUT
. When a
pin is configured as an INPUT
(using pinMode()), and read with digitalRead(), the microcontroller will report HIGH
if a
voltage of 3 volts or more is present at the pin.
When a pin is configured to OUTPUT
with pinMode()
, and set to
HIGH
with digitalWrite(), the pin is at
3.3 volts. In this state it can source current, e.g. light an LED
that is connected through a series resistor to ground, or to another
pin configured as an output and set to LOW
.
LOW¶
The meaning of LOW
also has a different meaning depending on
whether a pin is set to INPUT
or OUTPUT
. When a pin is
configured as an INPUT
with pinMode(), and
read with digitalRead(), the microcontroller
will report LOW
if a voltage of 2 volts or less is present at the
pin.
When a pin is configured to OUTPUT
with pinMode()
, and set to
LOW
with digitalWrite(), the
microcontroller will attempt to keep that pin’s voltage at 0 V. In this
state it can sink current, e.g. light an LED that is connected
through a series resistor to +3.3 V, or to another pin configured as an
output, and set to HIGH
.
Pin Modes¶
Digital pins can be used in a variety of modes. The basic modes,
INPUT
and OUTPUT
, have been introduced above. Changing a pin
from INPUT
TO OUTPUT
with pinMode()
drastically changes the electrical behavior of the pin.
This section describes the basic digital pin modes (INPUT
and
OUTPUT
) only. For a detailed description of all possible pin
modes, see the pinMode() reference page.
INPUT¶
Pins configured as INPUT
are said to be in a high-impedance
state. One way of explaining this is that pins configured as
INPUT
make very few demans on circuit that they are connected
to. This makes them useful for reading a sensor, but not powering an
LED.
OUTPUT¶
Pins configured as OUTPUT
with pinMode() are
said to be in a low-impedance state. This means that they can provide
a substantial amount of current to other circuits. Pins can source
(provide positive current) or sink (provide negative current) up to 50
mA (milliamps) of current to other devices/circuits. This makes them
useful for powering LEDs, but useless for reading sensors.
Pins configured as outputs can also be damaged or destroyed if short circuited to either ground or power supplies. The amount of current provided by a pin is also not enough to power most relays or motors, and some interface circuitry will be required.
Integer Constants¶
Integer constants are numbers used directly in a sketch, like
123
. By default, an integer constant is treated as a (signed)
int, but you can change this with the U and L
modifiers (see below). You can
specify negative numbers by putting a minus sign in front, like
-123
.
Normally, integer constants are treated as base 10 (decimal) integers, but special notation (formatters) may be used to enter numbers in other bases. These are explained in the following table:
Base | Example | Formatter | Comment |
---|---|---|---|
10 (decimal) | 123 |
None | |
2 (binary) | 0b1111011 |
Leading “0b” | GCC extension; not standard C++ |
8 (octal) | 0173 |
Leading “0” | Characters 0-7 valid |
16 (hexadecimal) | 0x7B |
Leading “0x” | Characters 0-9, A-F (or a-f) valid |
Binary constants (like B1111011
) for values between 0 and 255 are
supported for compatibility with Arduino only. You shouldn’t use them
in new programs.
Decimal is base 10. This is the common number system we learn in school. Integer literals without other prefixes are assumed to be in decimal format.
For example, the decimal literal 101
is one hundred and one: 1×102 + 0×101 + 1×100 = 101.
Binary is base two. Only characters 0 and 1 are valid. Binary
literals are indicated by the prefix 0b
.
For example, the binary literal 0b101
is five: 1×22 +
0×21 + 1×20 = 5.
Octal is base eight. Only characters 0 through 7 are valid. Octal
literals are indicated by the prefix 0
.
For example, the octal literal 0101
is sixty five: 1×82 +
0×81 + 1×80 = 65.
Warning
Bugs sometimes result by (unintentionally) including a leading “0” before an integer literal, which makes the compiler treat it as an octal number.
Hexadecimal (or “hex”) is base sixteen. Valid characters are 0
through 9 and letters A through F; A has the value 10, B is 11, up to
F, which is 15. Hex values are indicated by the prefix 0x
. A-F
can be typed in upper or lower case (a-f).
For example, the hexadecimal constant 0x101
is two hundred fifty
seven: 1×162 + 0×161 + 1×160 = 257.
The hexadecimal constant 0xCF2
is three thousand, three hundred
fourteen: 12×162 + 15×161 + 2×160 = 3314.
(Remember that in hex, A
means 10, and counting up, B
=11, so
C
=12 and F
=15).
U and L Suffixes¶
By default, an integer constant is treated as an int (and must be in the int type’s range limits). To specify an integer constant with another data type, follow it with:
- a
u
orU
to interpret the constant as an unsigned value. For example,33U
is an unsigned int. - an
l
orL
to interpret the constant as a long value. For example,100000L
is a long. On the Maple,long
is just a synonym forint
. - a
ul
orUL
to do both. For example,32767UL
is an unsigned long. On the Maple,unsigned long
is just a synonym forunsigned int
. - an
ll
orLL
to interpret the constant as a long long value. - a
ull
orULL
to interpret the constant as an unsigned long long.
Floating-Point Constants¶
A floating point constant is any number which includes a decimal
point. For instance, 3.0
is a floating-point constant for the
number 3. By default, a floating-point constant is a double. In order for the constant to be interpreted as a
float, you can write f
directly after it. For
example, 3.0f
is a floating-point constant with type float
.
Floating point constants can also be expressed in a variety of
scientific notation. E
and e
are both accepted as valid
exponent indicators. Some examples are given in the following table:
Floating-point constant | Evaluates to | Alternate expression |
---|---|---|
10.0 |
10 | |
2.34E5 |
2.34×105 | 234000.0 |
67e-12 |
67.0×10-12 | 0.000000000067 |
Board-Specific Constants¶
There are several board-specific constants whose value depends on which LeafLabs board you have. If you use them, it will help make sure that your code will work well on all LeafLabs boards, not just the one you have. This will make it easier to share your code with others.
For example, the pin number connected to the board’s built-in LED is different on the different boards, but the board-specific constant BOARD_LED_PIN will always be the correct value for each board.
See Also¶
- pinMode()
- Boolean Variables
- #define
- int
- unsigned int
- long
- unsigned long
- long long
- unsigned long long
- float
- double
- Board-Specific Values
License and Attribution
Portions of this page were adapted from the Arduino Reference Documentation, which is released under a Creative Commons Attribution-ShareAlike 3.0 License.