So lets start by revising quickly the logic truth tables, so we understand a bit better what we on about.

There are logical operators called AND, OR, NOT and XOR among others, that are the ones we will discuss now.

*While in digital systems, the gates work with 2 inputs at least, here we have to work with the 8 bits !

**Example**

*AND*binary number operation (the "*&*" is used in C programming for*AND*):01001011 &

10001101

=

00001001

**Example**

*OR*binary number operation ( the character "*|*" is the*OR*, used in C programming )01001011 |

10001101

=

11001111

**Example X**

*OR - Exclusive OR -*binary number operation ( the character*"^"**is the**OR*, used in C programming )- 01001011 ^

10001101

equals

11000110

```
```

```
* The NOT operator inverts the sense of the bit, so a 1 becomes a 0, and a 0 becomes a 1.
```

##
| = bit OR

& = bit AND

~ = bit NOT

^ = bit EXLUSIVE OR (XOR)

<< = bit LEFT SHIFT

>> = bit RIGHT SHIFT

## These operators work on bits and not logical values. Take two 8 bit bytes, combine with any of these operators, and you will get another 8 bit byte according to the operator's function. These operators work on the individual bits inside the byte.

## A truth table helps to explain each operation. In a truth table, a 1 bit stands for true, and a 0 stands for false.

- So we know we have

**DDRD = 0b**

*11111110**;*

*DDRD = DDRD | 0b**00000001**;*
This will "OR" it to a mask. The mask is:

**0b00000001**. While this looks like the actual binary number, if the previous**DDRD**was, say,**0b01001010**, then doing an**OR**to that with our mask would be:**0b01001010 | 0b00000001 = 0b01001011**. So this result only the pin 0 bit has changed!
This statememt can be further compressed in

**C++**:**DDRD |= 0b00000001;**

So why "

**"?***DDRD |= 1 << PIND0***1 << PINB0**is the act of creating the mask. The "

**1**" represents what will be inserted into the mask, the

**<<**is a left shift operator. It does EXACTLY what it says, and

**PIND0**is a number of positions that the "

**1**" will shift left. In essence,

**PIND0**is just equal to

**0**. So, you start with a

**0b00000000**, and you add a "

**1**" to make

**0b00000001**and then you shift it left

**0**positions. So you are left with

**0b00000001**, the same number from above. So, what if it was

**PIND4**? The statement would be:

**1 << PIND4**. The "

**1**" would be left shifted 4 times resulting in:

**0b00010000**. Remember, we are using a zero index, so there is four 0s after the 1.

We know how to set a specific bit in the binary number, but we don't know how to toggle a bit ( change it to 1 if it is a 0 and vice versa).

#include <avr/io.h>#include <util/delay.h>int main(void){DDRB |= 1 << PIND0;while (1){PORTB |= 1 << PINB0;_delay_ms(100);PORTB &= ~(1 << PINB0);_delay_ms(100);}}If the delay is going to be the same for on and off, we could shorten the previous four lines to only two and take advantage of theXORoperation.

The " ^ " Bitwise operator toggles the bit, so that if it is a 1 will then become a 0, and vice versa

#include <avr/io.h>

#include <util/delay.h>

int main(void)

{

DDRB |= 1 << PIND0;

while (1){PORTB ^= 1 << PINB0; */ The " ^ " Bitwise operator toggles the bit, so that if it is a 1 will then become a 0, and vice versa*/_delay_ms(100);}}*(...to be continued)

## No comments:

## Post a Comment

Feel free to contact me with any suggestions, doubts or requests.

Bless