Navigation

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.

Boolean Constants

There are two constants used to represent truth and falsity: true, and false.

false

false is the false bool value. An integer which is 0 evaluates to false as a boolean.

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 0V. In this state it can sink current, e.g. light an LED that is connected through a series resistor to +3.3V, 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

Maple (STM32) 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 extremely small demands on the circuit that they are sampling. 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. STM32 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 3.3V power rails. The amount of current provided by an STM32 pin is also not enough to power most relays or motors, and some interface circuitry will be required.

Integer Constants

Integer constants (or more properly speaking, integer literals) are numbers used directly in a sketch, like 123. By default, an integer literal 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 literals are treated as base 10 (decimal) integers, but special notation (formatters) may be used to enter numbers in other bases. These are summarized 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. Their use in new programs is discouraged.

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 (this is a GCC extension; it’s not standard C++).

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 interpret it in octal.

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 may be typed in upper or lower case (a-f).

For example, the hexadecimal literal 0x101 is two hundred fifty seven: 1×162 + 0×161 + 1×160 = 257.

The hexadecimal literal 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, with the attendant limitations in values. To specify an integer constant with another data type, follow it with:

  • a u or U to interpret the constant as an unsigned value. For example, 33U is an unsigned int.
  • an l or L to interpret the constant as a long value. For example, 100000L is a long. On the Maple, long is just a synonym for int.
  • a ul or UL to do both. For example, 32767UL is an unsigned long. On the Maple, unsigned long is just a synonym for unsigned int.
  • an ll or LL to interpret the constant as a long long value.
  • a ull or ULL to interpret the constant as an unsigned long long.

Floating-Point Constants

Similar to integer literals, floating point constants (properly: floating-point literals) are used to make code more readable. Floating point literals are swapped at compile time for the value to which the expression evaluates.

A floating point literal is any number which includes a decimal point. For instance, 3.0 is a floating-point literal for the number 3. By default, a floating-point literal is a double. In order for the literal to be interpreted as a float, you can write f directly after it. For example, 3.0f is a floating-point literal 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 literal 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 much 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.

Table Of Contents

Navigation

© Copyright 2010, LeafLabs, LLC. Last updated on May 23, 2011. Created using Sphinx 1.0.6.