diff options
Diffstat (limited to 'source/lang/api/constants.rst')
| -rw-r--r-- | source/lang/api/constants.rst | 94 |
1 files changed, 44 insertions, 50 deletions
diff --git a/source/lang/api/constants.rst b/source/lang/api/constants.rst index 3ba99f0..6f69dfe 100644 --- a/source/lang/api/constants.rst +++ b/source/lang/api/constants.rst @@ -62,7 +62,7 @@ pin is configured as an ``INPUT`` (using :ref:`pinMode() <lang-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 +When a pin is configured to ``OUTPUT`` with ``pinMode()``, and set to ``HIGH`` with :ref:`digitalWrite() <lang-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 @@ -82,9 +82,9 @@ pin. When a pin is configured to ``OUTPUT`` with ``pinMode()``, and set to ``LOW`` with :ref:`digitalWrite() <lang-digitalwrite>`, the -microcontroller will attempt to keep that pin's voltage at 0V. In this +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.3V, or to another pin configured as an +through a series resistor to +3.3 V, or to another pin configured as an output, and set to ``HIGH``. Pin Modes @@ -104,11 +104,11 @@ modes, see the :ref:`pinMode() <lang-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. +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. .. _lang-constants-output: @@ -117,31 +117,31 @@ OUTPUT Pins configured as ``OUTPUT`` with :ref:`pinMode() <lang-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. +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 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. +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. .. _lang-constants-integers: 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) :ref:`int <lang-int>`, but -you can change this with the U and L modifiers (see :ref:`below -<lang-constants-integers-u-l>`). You can specify negative numbers by -putting a minus sign in front, like ``-123``. +Integer constants are numbers used directly in a sketch, like +``123``. By default, an integer constant is treated as a (signed) +:ref:`int <lang-int>`, but you can change this with the U and L +modifiers (see :ref:`below <lang-constants-integers-u-l>`). You can +specify negative numbers by putting a minus sign in front, like +``-123``. -Normally, integer literals are treated as base 10 (decimal) integers, +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 summarized in the following table: +other bases. These are explained in the following table: .. list-table:: :header-rows: 1 @@ -172,8 +172,8 @@ other bases. These are summarized in the following table: - 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. +supported for compatibility with Arduino only. You shouldn't use them +in new programs. .. _lang-constants-integers-dec: @@ -187,8 +187,7 @@ For example, the decimal literal ``101`` is one hundred and one: 1×10\ .. _lang-constants-integers-bin: **Binary** is base two. Only characters 0 and 1 are valid. Binary -literals are indicated by the prefix ``0b`` (this is a :ref:`GCC -<arm-gcc>` extension; it's not standard C++). +literals are indicated by the prefix ``0b``. For example, the binary literal ``0b101`` is five: 1×2\ :sup:`2` + 0×2\ :sup:`1` + 1×2\ :sup:`0` = 5. @@ -203,19 +202,19 @@ For example, the octal literal ``0101`` is sixty five: 1×8\ :sup:`2` + .. warning:: Bugs sometimes result by (unintentionally) including a leading "0" before an integer literal, which makes the compiler - interpret it in octal. + treat it as an octal number. .. _lang-constants-integers-hex: **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). +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 literal ``0x101`` is two hundred fifty +For example, the hexadecimal constant ``0x101`` is two hundred fifty seven: 1×16\ :sup:`2` + 0×16\ :sup:`1` + 1×16\ :sup:`0` = 257. -The hexadecimal literal ``0xCF2`` is three thousand, three hundred +The hexadecimal constant ``0xCF2`` is three thousand, three hundred fourteen: 12×16\ :sup:`2` + 15×16\ :sup:`1` + 2×16\ :sup:`0` = 3314. (Remember that in hex, ``A`` means 10, and counting up, ``B``\ =11, so @@ -226,10 +225,10 @@ fourteen: 12×16\ :sup:`2` + 15×16\ :sup:`1` + 2×16\ :sup:`0` = 3314. U and L Suffixes ^^^^^^^^^^^^^^^^ -By default, an integer constant is treated as an :ref:`int -<lang-int>`, with the attendant :ref:`limitations in values -<lang-int-overflow>`. To specify an integer constant with another data -type, follow it with: +By default, an integer constant is treated as an :ref:`int <lang-int>` +(and must be in the int type's :ref:`range limits +<lang-int-overflow>`). 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 :ref:`unsigned int <lang-unsignedint>`. @@ -253,17 +252,12 @@ type, follow it with: 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 :ref:`double <lang-double>`. -In order for the literal to be interpreted as a :ref:`float -<lang-float>`, you can write ``f`` directly after it. For example, -``3.0f`` is a floating-point literal with type ``float``. +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 :ref:`double +<lang-double>`. In order for the constant to be interpreted as a +:ref:`float <lang-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 @@ -273,7 +267,7 @@ exponent indicators. Some examples are given in the following table: .. list-table:: :header-rows: 1 - * - Floating-point literal + * - Floating-point constant - Evaluates to - Alternate expression @@ -297,8 +291,8 @@ Board-Specific Constants There are several :ref:`board-specific constants <lang-board-values>` 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. +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 |