Arduino Bitwise operators
Bitwise Operators
& (bitwise and)
<< (bitshift left)
>> (bitshift right)
^ (bitwise xor)
| (bitwise or)
~ (bitwise not)
&
[Bitwise Operators]
Description
The bitwise AND operator in C++ is a single ampersand &, used between
two other integer expressions. Bitwise AND operates on each bit position of
the surrounding expressions independently, according to this rule: if both
input bits are 1, the resulting output is 1, otherwise the output is 0.
Another way of expressing this is:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 0 0 1 (operand1 & operand2) - returned
result
In Arduino, the type int is a 16-bit value, so using & between two int
expressions causes 16 simultaneous AND operations to occur.
Example Code
In a code fragment like:
int a = 92; // in binary: 0000000001011100
int b = 101; // in binary: 0000000001100101
int c = a & b; // result: 0000000001000100, or 68 in
decimal.
Each of the 16 bits in a and b are processed by using the bitwise AND, and
all 16 resulting bits are stored in c, resulting in the value 01000100 in
binary, which is 68 in decimal.
One of the most common uses of bitwise AND is to select a particular bit
(or bits) from an integer value, often called masking. See below for an
example (AVR architecture specific).
PORTD = PORTD & 0b00000011; // clear out bits 2 - 7, leave pins
PD0 and PD1 untouched (xx & 11 == xx)
<<
[Bitwise Operators]
Description
The left shift operator << causes the bits of the left operand to be
shifted left by the number of positions specified by the right operand.
Syntax
variable << number_of_bits;
Parameters
variable: Allowed data types: byte, int, long.
number_of_bits: a number that is < = 32. Allowed data types: int.
Example Code
int a = 5; // binary: 0000000000000101
int b = a << 3; // binary: 0000000000101000, or 40 in decimal
Notes and Warnings
When you shift a value x by y bits (x << y), the leftmost y bits in x are
lost, literally shifted out of existence:
int x = 5; // binary: 0000000000000101
int y = 14;
int result = x << y; // binary: 0100000000000000 - the first 1
in 101 was discarded
If you are certain that none of the ones in a value are being shifted into
oblivion, a simple way to think of the left-shift operator is that it multiplies
the left operand by 2 raised to the right operand power. For example, to
generate powers of 2, the following expressions can be employed:
Operation Result
--------- ------
1 << 0 1
1 << 1 2
1 << 2 4
1 << 3 8
...
1 << 8 256
1 << 9 512
1 << 10 1024
...
The following example can be used to print out the value of a received byte
to the serial monitor, using the left shift operator to move along the byte
from bottom(LSB) to top (MSB), and print out its Binary value:
// Prints out Binary value (1 or 0) of byte
void printOut1(int c) {
for (int bits = 7; bits > -1; bits--) {
// Compare bits 7-0 in byte
if (c & (1 << bits)) {
Serial.print("1");
}
else {
Serial.print("0");
}
}
}
>>
[Bitwise Operators]
Description
The right shift operator >> causes the bits of the left operand to be
shifted right by the number of positions specified by the right operand.
Syntax
variable >> number_of_bits;
Parameters
variable: Allowed data types: byte, int, long.
number_of_bits: a number that is < = 32. Allowed data types: int.
Example Code
int a = 40; // binary: 0000000000101000
int b = a >> 3; // binary: 0000000000000101, or 5 in decimal
Notes and Warnings
When you shift x right by y bits (x >> y), and the highest bit in x is a 1,
the behavior depends on the exact data type of x. If x is of type int, the
highest bit is the sign bit, determining whether x is negative or not, as we
have discussed above. In that case, the sign bit is copied into lower bits,
for esoteric historical reasons:
int x = -16; // binary: 1111111111110000
int y = 3;
int result = x >> y; // binary: 1111111111111110
This behavior, called sign extension, is often not the behavior you want.
Instead, you may wish zeros to be shifted in from the left. It turns out that
the right shift rules are different for unsigned int expressions, so you can
use a typecast to suppress ones being copied from the left:
int x = -16; // binary: 1111111111110000
int y = 3;
int result = (unsigned int)x >> y; // binary: 0001111111111110
If you are careful to avoid sign extension, you can use the right-shift
operator >> as a way to divide by powers of 2. For example:
int x = 1000;
int y = x >> 3; // integer division of 1000 by 8, causing y =
125.
^
[Bitwise Operators]
Description
There is a somewhat unusual operator in C++ called bitwise EXCLUSIVE
OR, also known as bitwise XOR. (In English this is usually pronounced "eks-
or".) The bitwise XOR operator is written using the caret symbol ^. A
bitwise XOR operation results in a 1 only if the input bits are different, else
it results in a 0.
Precisely,
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 0 (operand1 ^ operand2) - returned result
Example Code
int x = 12; // binary: 1100
int y = 10; // binary: 1010
int z = x ^ y; // binary: 0110, or decimal 6
The ^ operator is often used to toggle (i.e. change from 0 to 1, or 1 to 0)
some of the bits in an integer expression. In a bitwise XOR operation if
there is a 1 in the mask bit, that bit is inverted; if there is a 0, the bit is not
inverted and stays the same.
// Note: This code uses registers specific to AVR
microcontrollers (Uno, Nano, Leonardo, Mega, etc.)
// it will not compile for other architectures
void setup() {
DDRB = DDRB | 0b00100000; // set PB5 (pin 13 on Uno/Nano, pin
9 on Leonardo/Micro, pin 11 on Mega) as OUTPUT
Serial.begin(9600);
}
void loop() {
PORTB = PORTB ^ 0b00100000; // invert PB5, leave others
untouched
delay(100);
}
|
[Bitwise Operators]
Description
The bitwise OR operator in C++ is the vertical bar symbol, |. Like the &
operator, | operates independently each bit in its two surrounding integer
expressions, but what it does is different (of course). The bitwise OR of two
bits is 1 if either or both of the input bits is 1, otherwise it is 0.
In other words:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 1 (operand1 | operand2) - returned result
Example Code
int a = 92; // in binary: 0000000001011100
int b = 101; // in binary: 0000000001100101
int c = a | b; // result: 0000000001111101, or 125 in
decimal.
One of the most common uses of the Bitwise OR is to set multiple bits in a
bit-packed number.
// Note: This code is AVR architecture specific
// set direction bits for pins 2 to 7, leave PD0 and PD1
untouched (xx | 00 == xx)
// same as pinMode(pin, OUTPUT) for pins 2 to 7 on Uno or Nano
DDRD = DDRD | 0b11111100
~
[Bitwise Operators]
Description
The bitwise NOT operator in C++ is the tilde character ~. Unlike & and |,
the bitwise NOT operator is applied to a single operand to its right. Bitwise
NOT changes each bit to its opposite: 0 becomes 1, and 1 becomes 0.
In other words:
0 1 operand1
-----
1 0 ~operand1
Example Code
int a = 103; // binary: 0000000001100111
int b = ~a; // binary: 1111111110011000 = -104
Notes and Warnings
You might be surprised to see a negative number like -104 as the result of
this operation. This is because the highest bit in an int variable is the so-
called sign bit. If the highest bit is 1, the number is interpreted as
negative. This encoding of positive and negative numbers is referred to as
two’s complement. For more information, see the Wikipedia article on two’s
complement.
As an aside, it is interesting to note that for any integer x, ~x is the same
as -x - 1.
At times, the sign bit in a signed integer expression can cause some
unwanted surprises.
