```

_________________

/_               /\

\/  _______    /  \

/  /      /   /   /

/  /______/   /   /

/           __/   /

/  _______   \  __/

/  /      /   /  \

/  /______/   /   /

_/             /   /

/______________/   /       BLACK SUN RESEARCH FACILITY

\              \  /      	   http://blacksun.box.sk/

\______________\/

BOOLEAN LOGIC GATES

=================================================

WRITTEN BY                 [ cos125@hotmail.com                :E-MAIL    ]

BINARY RAPE        [ 114603188                         :ICQ#      ]

[ http://blacksun.box.sk/           :TURORIALS ]

CONTENTS

=======================================

1.  Introduction.

2.  A Quick Look At Binary.

2.1 A Little Conversion

3.  The Logic Gates.

3.1 The Not Gate

3.2 The And Gate

3.3 The Or Gate

4.  Negated Gates.

4.1 The Nand Gate

4.2 The Nor Gate

5.  The Exclusive Gates.

5.1 The Xor Gate

5.2 The Xnor Gate

7.  Last Words.

____________________________________________________________________________________________

1.0 INTRODUCTION

=======================================

Before reading this tutorial i suggest you read the bsrf tutorial on

different number base's and the first few sections of the bsrf assembly

tutorial unless you are confident that you understand binary and and

a bit of boolean algebra would help, never the less continue on and

I hope that things become clear to you.

2.0 A QUICK LOOK AT BINARY

=======================================

Basically binary is very simple, we as people are used to counting in

decimal, 1,2,3, etc..., this is known as base 10 as their are 10 numbers

in decimal 0,1,2,3,4,5,6,7,8,9 and no 10 is not one of them, to get ten

we put 1 and 0 together when we move past 9, we do this in order to count

higher, obviously, and once we get passed 9 we go back to 0 move over one

space and put on a 1.

0

1

2

3

4

5

6

7

8

9  <- Reached the maximum of our numbers in decimal

10  <- So we move over one place and put on a 1 and start again

11

12

13

14

15

16

17

18

19  <- Again we reach the maximum so we move over one place and add a 1

20

21

..

..

90  <- And so on till we reach 90

91

92

93

94

95

96

97

98

99  <- Weve now reached the maximum on both numbers so we have to move 2 places over and add a 1

100  <- And the cycle starts again

What we have to remember is that decimal has 10 numbers and is therefore

known as base10, binary only has 2 numbers, 1 and 0 and is therefore known

as base 2, but what happens when we try and lay out the binary numbers like

we did above with the decimal ones?

0

1  <- Already weve reached the maximum of binary numbers!

10  <- Like decimal we move over and start again

11  <- So quickly weve already run out on both sides

111  <- like the decimal number 1 hundred we move over 2 and start again

As you can see there isnt much to binary, lets count to ten in binary

to get a little more used to it.

Decimal		Binary

-------		------

0		  00

1		  01

2		  10

3		  11

4		 100

5	 	 101

6		 110

7		 111

8		1000

9		1001

10		1010

See binary is easy enough and if you leave out the first column

you will notice that 4 - 7 look like 0 - 3 and remember its just

like going from 9 to 10 in decimal, move over 1 place and add on

a 1.

2.1 A LITTLE CONVERSION

=======================================

So how do we convert from decimal to binary numbers? Sure you could

write out a table like above and check it to get the binary value

you want but what if your looking for a value for a number like

1275, good look writing a table up to 10011111011 or we could just

use the good old repeated division of 2 method. This works by

repeatedly dividing the decimal number by 2 and if its an even number

record a 0, if its an odd record a 1. Say for example we wanted to

convert 57 to binary:

2/57  remainder = 1

= 28

2/28  remainder = 0

= 14

2/14  remainder = 0

=  7

2/7  remainder = 1

=  3

2/3  remainder = 1

=  1

2/1  remainder = 1

=  0

Now if we put those remainders alongside eachother starting from the

bottom up we get 111001, which is 57 in binary.

3.0 THE LOGIC GATES

=======================================

Well binary is nice n easy n all but if thats all that a computer

understands then how does it go from that to a word processor or an

entire operating system. Well we build up these complicated tasks

using simple logic gates and boolean algebra, boolean algebra was

created by George Boole in Ireland in the 1800's, wahey. The gates

provide a way to make decisions and more complex tasks are built

upon them. These gates accept input of Binary numbers and their output

is based on the type of gate and what input was involved. There are

three simple gates.

3.1 THE NOT GATE

=======================================

The simplest of all the gates is the NOT gate, it just takes a binary

value of either 1 or 0 and gives back the oppossite. The NOT gate is

symbolised by the operator '~'. Consider the following.

A   |   Q

------+-------

0   |   1

1   |   0

~0 = 1

~1 = 0

This table shows all possible inputs and outputs of the NOT gate, this

kind of a table is known as a 'truth table'. Fig 1.0 Standard NOT Gate

3.2 THE AND GATE

=======================================

The AND gate unlike the NOT gate doesnt take just one input (A) it takes

at least 2 (A,B), its symbol is '&'.

A  B  |  Q

-------+------

0  0  |  0

0  1  |  0

1  0  |  0

1  1  |  1

0 & 0 = 0

0 & 1 = 0

1 & 0 = 0

1 & 1 = 1

As you can see from the truth table above, the output of a AND gate

is only equal to 1 when both A AND B are equal to 1, this is the

following.

If A = 0 and B = 0 then Q = 0

If A = 0 and B = 1 then Q = 0

If A = 1 and B = 0 then Q = 0

If A = 1 and B = 1 then Q = 1 Fig 1.1 Standard AND Gate

3.3 THE OR GATE

=======================================

The OR gate also only takes in 2 parameters, A and B, its symbol is '|'

A  B  |  Q

-------+------

0  0  |  0

0  1  |  1

1  0  |  1

1  1  |  1

0 | 0 = 0

0 | 1 = 1

1 | 0 = 1

1 | 1 = 1

The OR gate outputs a value of 1 if either A OR B OR both are equal

to 1

If A = 0 and B = 0 then Q = 0

If A = 0 and B = 1 then Q = 1

If A = 1 and B = 0 then Q = 1

If A = 1 and B = 1 then Q = 1 Fig 1.2 Standard OR Gate

4.0 NEGATED GATES

=======================================

There are 2 Negated Gates, these are the NOR and NAND gates. Basically

these gates act like an OR and AND gate only there output is the opposite.

4.1 THE NAND GATE

=======================================

The truth table of a NAND gate is as follows

A  B  |  Q

-------+------

0  0  |  1

0  1  |  1

1  0  |  1

1  1  |  0

Notice that it is the opposite of an AND gate.

0 & 0 = 0, ~0 = 1

To wrap this up a bit better we use brackets ()

~(0 & 0) = 1

~(0 & 1) = 1

~(1 & 0) = 1

~(1 & 1) = 0

Now the result of the calcuation in the brackets is negated. Fig 1.3 Standard NAND Gate

4.2 THE NOR GATE

=======================================

The truth table for the NOR gate is as follows

A  B  |  Q

-------+------

0  0  |  1

0  1  |  0

1  0  |  0

1  1  |  0

~(0 | 0) = 1

~(0 | 1) = 0

~(1 | 0) = 0

~(1 | 1) = 0 Fig 1.4 Standard NOR Gate

5.0 THE EXCLUSIVE GATES

=======================================

The final 2 gates remaining are the XOR (eXclusive OR) and

XNOR (eXclusive NOR) gates. Here they are.

5.1 THE XOR GATE

=======================================

The logic behind this gate is that if either A or B is equal

to 1 but not both then the output is equal to 1, here is its

truth table.

A  B  |  Q

-------+------

0  0  |  0

0  1  |  1

1  0  |  1

1  1  |  0

The gate is constructed as follows.

(A & ~B) | (~A & B)

(0 & ~0) | (~0 & 0)  = 0

(0 & ~1) | (~0 & 1)  = 1

(1 & ~0) | (~1 & 0)  = 1

(1 & ~1) | (~1 & 1)  = 0 Fig 1.5 Standard XOR Gate

5.2 THE XNOR GATE

=======================================

The XNOR gate is simply the opposite of the XOR gate, its truth

table looks like the following.

A  B  |  Q

-------+------

0  0  |  1

0  1  |  0

1  0  |  0

1  1  |  1

Its kind of like ~((A & ~B) | (~A & B)).

This is a good time to point out something about boolean algebra,

remember that ~ changes the value of an input to its opposite,

therefore ~(~A) = A and the 2 ~'s simply cancel eachother out.

So XNOR becomes (~A & B) | (A & ~B). Fig 1.6 Standard XNOR Gate

=======================================

So we all know how to add decimal numbers (im presuming), its easy

1	1	1

+ 1      + 2      + 3

---      ---      ---

= 2      = 3      = 4

But how do we add in binary? Easy watch this

0	0	1	 1

+ 0      + 1       + 0       + 1

---      ---       ---       ---

= 0      = 1       = 1      = 10

Thats fine but with 1+1 we get a carry over that we have to deal with.

So we add an extra space to handle the carry.

0	0	1	1

+ 0      + 1      + 0       + 1

---      ---      ---       ---

= 00     = 01     = 01      = 10

Lets write a truth table to handle this data.

A  B  |  CO Q

-------+--------

0  0  |  0  0

0  1  |  0  1

1  0  |  0  1

1  1  |  1  0

Notice the new column on the truth table for the carry out (CO).

We now notice that CO and Q and familiar, C0 is the same as an AND

gate and Q is the same as an XOR.

A & B = Q

(A & ~B) | (~A & B) = CO

Thats fine for adding single bit numbers but what if we want to add

2 8-bit numbers? In this case were going to need a component called a

full binary adder. Once we create the full adder we can put 8 of them

together to form an 8-bit or byte-wide adder and move the carry bit from

The main difference for us between the first adder and this full adder

is that we now need a third input called a Carry-In (CI).

Heres the truth table for the full adder.

A   B  CI  |  CO Q

-------------+--------

0   0   0  |  0  0

0   0   1  |  0  1

0   1   0  |  0  1

0   1   1  |  1  0

1   0   0  |  0  1

1   0   1  |  1  0

1   1   0  |  1  0

1   1   1  |  1  1

If we examine the output youll realise that the top 4 numbers for C0

look like an AND gate for A and B and the bottom 4 look like an OR

gate for A and B, while top 4 of Q look like an XOR and the bottom 4

like an XNOR gate.

By putting those gates together we could form a form a more complicated

and useful circuit such as the adder and thats how a computer builds

up from a series of 1's and 0's to addition.

7.0 LAST WORDS

=======================================

Well in this tutorial we looked at Logic Gates and how they perform

functions on binary numbers, Gates can be used to build up much better

and sophisticated functions such as loops and comparisons, used together

these can easily perform multiplication and division and we can use

these in everyday equipment, from washing machines and microwave ovens

to motion sensitive cameras and pc's.

SHOUTS

=======================================

Starman_Jones		- Thanks for everything over the years (especially for my own room).

Vsus			- I am never drinking Tsambuca with you again :P.

Delusive			- Nice arse luv :P.

BSRF			- Thanks to every-1 at BSRF for releasing this and for being a good laugh :).

ALL @ IRC.BOX.SK

```