The document discusses using bitwise operators like OR (|) and AND (&) to set and clear individual bits in registers. It explains how to use the _BV() macro to make bit manipulation code more readable by representing single bits as bit masks. Examples are given of using bitwise operators and _BV() to set, clear, and toggle single bits as well as multiple non-contiguous bits in registers like PORTC.

1. hoangpt
First, the only reliable way to work with the bits in a register is to use the OR and AND operators: “|” and
“&” and in simple terms, you use OR to set one or more bits without affecting the others and you use AND
(with the ones - complement – the inverse – of the bit pattern) to similarly clear bits. Here are some simple
examples:
device_reg = device_reg | 0x01; // set bit 0
device_reg = device_reg & ~0x061; // clear bit 1
Now, we would probably use the compound assignment operators and write the code like this:
device_reg |= 0x01; // set bit 0
device_reg &= ~0x01; // clear bit 1
If you want to toggle/flip a bit, the exclusive-OR operator in C is “^” which works in the same way.
The _BV() is a compiler macro defined as #define _BV(bit)(1<<(bit)) in library <avr/sfr_defs.h> which
was included already indirectly through <avr/io.h>. It stands for bit value where you pass it a bit and it gives
you the byte value with that bit set. As we seen already, in the C language one assigns and tests bits using bit
operators, the assign operator, and the concept of bit masks:
PORTC |= 0x01; // Set bit 0 only.
PORTC &= ~0x01; // Clear bit 0 only.
PORTC ^= 0x01; // Toggle bit 0 only.
PORTC & 0x01; // Test bit 0 only.
PORTC |= 0x80; // Set bit 7 only.
Using macros make this easier to read. The _BV() macro in avr-libc takes a number as the argument
and converts it to the appropriate bit mask. (The BV stands for Bit Value). The _BV() macro is defined as:
#define _BV(x) (1 << x)
/* This allows */
PORTC |= _BV(0); // Set bit 0 only.
PORTC &= ~(_BV(1)); // Clear bit 1 only.
PORTC ^= _BV(7); // Toggle bit 7 only.
Using bit operators, one can do multiple, non-contiguous bits at a time:
PORTC |= (_BV(0) | _BV(2) | _BV(7)); // Set bits 0, 2, 7
PORTC &= ~(_BV(1) | _BV(2) | _BV(6)); // Clear bits 1, 2, 6
PORTC ^= (_BV(5) | _BV(3)); // Toggle bits 3, 5
The | symbol between each _BV macro statement means logically OR
Eg: (_BV(0) | _BV(2) | _BV(7)); // logically OR’s the bits together
/*
Name bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
_BV(0) = 0 0 0 0 0 0 0 1
_BV(2) = 0 0 0 0 0 1 0 0
_BV(7) = 1 0 0 0 0 0 0 0
or’ed = 1 0 0 0 0 1 0 1
*/

2. hoangpt
A further example is:
UCSRB = _BV(TXEN)|_BV(RXEN)|_BV(RXCIE); // TX/RX enable, RX complete
In each iteration of the infinate loop [while (1)] we are using standard C methods for setting and clearing
the PC0 bit followed by 1000ms delay between each set and each clear. Let's take a closer look at each of
those.
The first, is to clear the bit using PORTC &= ~_BV(PB0); which turns off the PIN (remember that the
PIN is connected to VCC, so a logical 1 output results in little to no voltage across the PIN). Remember that
our _BV macro returns the bit set in byte form in this case, 0x01 or 00000001b. So, the statement PORTB &=
~_BV(PB0); is actually PORTB &= ~0x01;
The bitwise operator ~ will "not" the value first, which results in 11111110b. So now we basically have
PORTB &= 0xFE;. With this, the bit in position 0, PB0, will always be cleared after this statement without
effecting the other bits in the byte. So regardless of the value currently in PORTB, only the bit we're clearing is
changed.
#define F_CPU 16000000UL /* 16 MHz Internal Oscillator */ #include <avr/io.h>
#include <util/delay.h>
/* function for long delay */
void delay_ms(uint16_t ms) { // Trong thư viện delay.h đã có sẵn hàm _delay_ms(ms)
while ( ms )
{ _delay_ms(1);
ms--;
}
}
int main (void)
{
/* PB5 is digital output */
DDRB = _BV (0);
/* loop forever */
while (1)
{
/*clear PB0 on PORTB (digital high)
and delay for 1 second*/
PORTB &= ~_BV(0);
delay_ms(1000);
/* set PB0 on PORTB (digital low) and delay for 1 Second */
PORTB |= _BV(0);
delay_ms(1000);
}
}