raspibo - Contributi utente [it]

No more secrets Part 7:A computer must be able to compute!

2015-02-09T14:16:27Z

GiuliaN:

We have seen circuits that can be used to select or route signals.

The main function of a computer is (obviously) to perform computations.
The basic computation is the sum.

We are going to implement a full adder: a circuit that sums three bits
together and provides two output bits, result and carry.
In fact, to add two numbers having an arbitrary number of digits we need
an algorithm to add three digits together. If you remember the algorithm
to sum two numbers learnt in the elementary school, the sum must proceed
column by column, right to left, in each column you have
to add the two digits of both numbers plus the carry resulted in the
computation of the previous column. You'll get two results in each column:
the digit of the result and the new carry to be used in the computation
of the following column.

<pre>
inA inB Cin Cout Out
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
</pre>

From a closer look of the table it appears that the output is the count of
the number of bits set to one in the input, encoded in binary.
When the inputs are all zero the output is 00, all the configurations where
there is only one bit set to 1 in the input (001, 010, 100) the output is
01, if two bits are one (011, 101, 110) the output is 10 and finally when
all the input bits are set, the output is 11.

The most significant bit of the result has been named Cout, carry out
as it has to be connected to the Cin input of another full adder in order
to build a chain of adders able to sum an arbirary number of bits.

[[File:adderchain.jpg]]

We need 9 NAND gates to implement a full adder on out breadboard.

[[File:fulladder.jpg]]

This is the table of the jumpers
<pre>
inA: AB
inB: AC
Cin: EG
A: BCI
B: D
C: D
D: EF
E: FGI
F: H
G: H
H: out
I: JJ Cout
J: Rcout

</pre>
(Rcout is not currently used. It will be later used to implement the
circuit of an entire ALU)

It is interesting to see how a simple circuit can compute a sum of three
bits.

Several full adder bradboards can be chained to sum binary numbers.
Using three boards it is possible to sum numbers from 0 to seven, four
boards permit to sum numbers in the range zero to fifteen.

[[File:adder4boards.jpg]]

The circuit of the full adder uses two XOR gates to compute the result.
In fact the result of the sum of two bits (not considering the carry bit)
is a xor:

<pre>
inX inY out
0 0 0
0 1 1
1 0 1
1 1 0 (and carry=1)
</pre>

The circuit is implemented as two, two-bit adders in a pipeline.

[[File:adderxor.jpg]]

For what concerns the carry, in the sum of two bits the carry is one
when both inputs are one, thus it is the reault of an AND gate.

When the two two-bit adders are chaines in a pipeline to sum three bits
at most one two-bit adder can generate a carry.
The carry of the full adder is the result of an OR between the carry output
of the two two-bit adders.

[[File:adderxorcarry.jpg]]

The full adder circuit implemented on the breadboard is the one depicted
here above, implemented using only NAND gates.

No more secrets Part E: Shift to Multiply and Divide

2014-10-22T15:02:52Z

GiuliaN:

This is a left shift circuit for three bits:

[[File:leftshift_v2.jpg]]

and the jumper table:

<pre>
in3 -> A
in2 -> BD
in1 -> EG
in0 -> JH
SL -> BEH
NSL -> ADGJ
A -> C
B -> C
C -> out3
D -> F
E -> F
F -> out2
G -> I
H -> I
I -> out1
J -> KK
K -> out0
</pre>

To test this circuit exactly one of the inputs SL or NSL must be set to
one. When NSL is one the 4 input bits are copied to the outputs.
When SL is one in0 is copied to out1, in1 to out2, in2 to out3 and out0 is
zero. If we give to the four input bits the meaning of the binary
representation of a number, when SL is one the result is the input times
two. The result is correct both for signed and unsigned numbers provided
the result can be stored in four bits.

For esample:
<pre>
leftshift(3) = leftshift(0011) = 0110 = 6 (both for unsigned and signed numbers)

leftshift(5) = leftshift(0101) = 1010 = 10 (unsigned only!)

leftshift(-3) = leftshift(1101) = 1010 = -6 (signed)
</pre>

It is possible to test the circuit in this way: plug four leds on the
output and connect NSL to one (positive rail). Now set a random input
configuration, you'll see the same configuration in the pattern of
leds. Moving the jumper from NSL to SL the led pattern will move (left) and the
least significant bit will be zero.

A right shift circuit can divide values by two in a similar manner.
Unfortunately, in this case signed and unsigned numbers must be processed
in a different way.

This is the circuit:

[[File:rightshift_v2.jpg]]

and the jumper table:
<pre>
in3 -> AC
in2 -> DF
in1 -> GI
in0 -> J
SR -> CFI
NSR -> DGJ
copy3 -> A
A -> BB
B -> out3
C -> E
D -> E
E -> out2
F -> H
G -> H
H -> out1
I -> K
J -> K
K -> out0
</pre>

Now the valid configurations for SR, NSR and copy3 are the following ones:
<pre>
SR NSR copy3
0 1 1 copy all the inputs in the corrisponding outputs
1 0 0 shift right for unsigned (the MSB is zero)
(also known as logical shift)
1 0 1 shift right for signed (the MSB is copied)
(A.K.A. arithmetic shift)
</pre>

The difference between a logical shift and an arithmetic shift is the
management of the Most Significant Bit (MSB, i.e. out3):
a logical shift resets it to zero while an arithmetic shift copies the
former value of the MSB, out2 and out3 has always the same value in
an arithmetic shift.
In other words, an arithmetic shift keeps the sign bit unchanged.

A logical right shift is a division by two operation for unsigned integers.
An arithmentic right shift is a division by two only for positive integers
and for even negative numbers. For odd negative numbers the result is
rounded downwards, so incorrect.

<pre>
(any kind of right shift, logical or arithmetic).
rightshift(3) = leftshift(0110) = 0011 = 3
(both for unsigned and signed numbers)

logical_rightshift(10) = logical_rightshift(1010) =
= 101 = 5 (unsigned only!)

arithmetic_rightshift(-6) = arithmetic_rightshift(1010) =
= 1101 = -3 (signed)

arithmetic_rightshift(-3) = arithmetic_rightshift(1101) =
= 1110 = -2 (signed)
</pre>

A complete and flexible shifter can be implemented using three breadboards.

[[File:completeshifter.jpg]]

The shift control circuit has two control bits sh0 and sh1 supporting
the following configurations:
<pre>
sh1 sh0
0 0 do not shift
0 1 left shift
1 0 (logical) right shift
1 1 arithmetic right shift
</pre>

This is the circuit and the map for the jumpers:

[[File:shiftcontrol.jpg]]

<pre>
sh1 -> AABC outSR
sh0 -> BD
A -> outNSR
B -> CD
C -> outcopy3
D -> EE outNSL
E -> outSL
</pre>

File:Rightshift v2.jpg

2014-10-22T15:01:57Z

GiuliaN:

File:Leftshift v2.jpg

2014-10-22T15:01:40Z

GiuliaN:

No more secrets Part C: Is it smaller, larger or overflows?

2014-10-22T15:00:58Z

GiuliaN:

The overflow and compare module is provided in two 'flavours'.

The simplest module does not require any breadboard. This module is not able
and the L bit to the Rcout output of the same to work on signed data. The V and
L output lines are simply connected respectively to the Cout and Rcout outputs
of the full adder of the most significant bit.

This is the 'circuit':

[[File:overflow0.jpg]]

The second implementation requires all the NAND gates of a breadboard
and is able to detect overflows and compute comparisons on signed and
unsigned numbers.
There is a specific input 'signed' which determines whether the data
are to be regarded as signed or unsigned and uses the correct
overflow detection or comparison algorithm.

It is worth recalling that all the other components of the ALU compute
sums, subtractions using signed or unsigned numbers anyway, no matters which
overflow/comparison circuit we are using. The computations are the same,
input and output data just uses different encodings.

This is the circuit:

[[File:overflow_v2.jpg]]

and this is the map for jumpers:

<pre>
Signed -> AG
Rout -> BD
Cin -> A
N -> FF
A -> BC
B -> CD
C -> E
D -> E
E -> HJ outV
F -> G
G -> HI
H -> IJ
I -> K
J -> K
K -> outL
</pre>

File:Overflow v2.jpg

2014-10-22T15:00:09Z

GiuliaN:

No more secrets Part A: A complete ALU

2014-10-22T14:59:24Z

GiuliaN:

An ALU is not just an adder, it is a circuit which is able to perform
several kinds of computations: both Arithmetic and Logic operations.
Our ALU is able to compute sums, subtractions, comparisons, and/or/not
bitwise logical operations, sign change, etc.

An ALU has a number of control input line which select the operation,
two sets of input lines (two buses) for the operands and an output bus
for the result.

The implementation of our ALU requires three breadboard per bit plus
two breadboard for zero and overflow detection.
A complete four-bit ALU then requires 14 breadboards, a three-bit ALU
just 11. Zero and overflow detection circuits are optional.

Do not skip this section if you don't have so many breadboards or so many
friends to play with. It is possible to test each block separately and
use your imagination to envision how the entire structure behaves.

Each bit of our ALU is composed by a three breadboards: a full adder,
a two-control bits multiplexer and the logical unit. We have already
presented the two former circuits, the latter one is presented in the
following part of this chapter.

The block schematics is the following one:

[[File:ALU1bit.jpg]]

Several 1-bit ALUs can be connected/chained together.
It is possible to add an overflow and a zero check circuits.

[[File:ALU4bit.jpg]]

The logical unit selects which inputs are used in the computation and
performs some logical computations: 'and', 'or'.

The schematics of our logical unit is in the following picture:

[[File:logical_v2.jpg]]

This is the map of the jumpers:

<pre>
inA -> A
enA -> A
inB -> B
enB -> B
invB -> CE
A -> GGK
B -> CD
C -> DE
D -> F
E -> F
F -> HHK
G -> I,outA
H -> I,outB
I -> JJ
J -> outAND
K -> outOR
</pre>

This circuit has two data inputs: inA and inB. These inputs get the
value of two corresponding bits to be processed.

There are three control input bits: enA, enB and invB.
The prefix 'en' means 'enable': if enA is zero the value of inA is
ignored, discared, i.e. inA is taken into consideration for the computation
only when enA is true. When enA is zero the first operand of the full
adder, of the 'and' operation , of the 'or' operator is zero.
Similarly enB is the enable bit for inB. When invB is one the value of B
is negated. So when enB is 1 the input for the second operand of the full
adder and of the logical operators (and, or) is B, or not B when invB is 1.
If enB is zero, the input of that second operand has the same value of invB.

So, outA and outB have been pre-processed to be the inputs of the full adder.

<pre>
inA inB invB outA outB outAND outOR
0 0 0 0 0 0 0
0 0 1 0 1 0 1
0 1 0 0 B 0 B
0 1 1 0 notB 0 notB
1 0 0 A 0 0 A
1 0 1 A 1 A A
1 1 0 A B AandB AorB
1 1 1 A notB Aand(notB) Aor(notB)
</pre>

File:Logical v2.jpg

2014-10-22T14:58:38Z

GiuliaN: GiuliaN ha caricato una nuova versione di "File:Logical v2.jpg"

File:Logical v2.jpg

2014-10-22T14:52:56Z

GiuliaN:

Renzo's Bliki

2014-10-22T13:58:07Z

GiuliaN:

Insomma... io ho un sacco di cose da dire e da scrivere e non so mai dove metterle in questo magnifico wiki di RaspiBO.
Soffro di ritenzione comunicativa.

Pertanto attivo qui il mio Bliki: Una specie di Blog creato su di un wiki!
Mettero' man mano articoli (provvisti di data).

I contenuti sono comunque qui. Se qualche anima gentile poi vorrà catalogare meglio i contenuti o riscrivere le idee
in modo migliore... avra' la mia gratitudine.

renzo. Oct 28, 2013.

=== 2014 October ===

October 13: [[Seminar @ Maker Faire: slides and more]]

=== 2014 September ===

September 21: [[Millefori: draw, print, mill and drill your experimental PCBs]]

September 14: [[Gert's VGA board for Raspberry PI B+ using off the shelf components]]

=== 2014 August ===

August 19: [[A new laser cutter/engraver for my Wasp 3D printer]]

August 14: [[No more secrets Part 11: Is this a divisor or a counter?]]

August 14: [[No more secrets Part 10: Synchronous memory]]

August 14: [[No more secrets Part F: Circuits to remember]]

August 14: [[No more secrets Part E: Shift to Multiply and Divide]]

August 14: [[No more secrets Part D: Here is the ALU: all together now!]]

August 14: [[No more secrets Part C: Is it smaller, larger or overflows?]]

August 14: [[No more secrets Part B: Is it zero?]]

August 14: [[No more secrets Part A: A complete ALU]]

August 14: [[No more secrets Part 9: An adder can subtract, too]]

August 14: [[No more secrets Part 8: More or Less? A trick to process signed numbers]]

August 14: [[No more secrets Part 7:A computer must be able to compute!]]

August 14: [[No more secrets Part 6: Let us play together]]

=== 2014 June ===

June 10: [[No more secrets Part 5: Mux Demux ]]

=== 2014 May ===

May 27: [[No more secrets Part 4: Encode and Decode... ]]

May 27: [[s2argv-execs: something was missing in libc]]

May 16: [[No more secrets Part 3: A NAND is for everything]]

May 16: [[No more secrets Part 2: Let us build the experimental board]]

May 14: [[No more secrets in your CPU: Part 1]]

May 9: [[Melodic irrationalities]]

=== 2013 November ===

Nov. 1: [[Why Intel Galileo is not my favourite platform]]

=== 2013 October ===

Oct. 7: [[Esperimenti con Intel Galileo]]

=== 2013 August ===

Aug. 13: [[Una stampa 3D per la doccia]]

Aug. 06: [[Cronaca dei miei primi esperimenti di CNC]] (Renzo)

No more secrets Part 11: Is this a divisor or a counter?

2014-10-20T09:23:49Z

GiuliaN:

The answer is "both". The circuit presented in this section is, at the
same time, a circuit to divide a frequency by two and an element to build a
counter, i.e. a circuit which counts.
In fact, our circuit will switches its status each time the input value
goes from one to zero (on the falling edge of the binary signal, in
technical jargon).
Here is the circuit:

[[File:divisor.jpg]]

<pre>
ck -> ABEE
A -> C
B -> D
C -> DF
D -> CG
E -> FG
F -> H
G -> I
H -> BI out
I -> AH
</pre>

To test this circuit, connect the input ck to the master clock and plug in
two leds, one to the master clock output and the other to the output (out)
of our circuit.
If everything works properly you will see that the led connected to the
output switches its state, zero to one or one to zero, when the other
led turns off. So, if the master clock led is flashing at about 1Hz, the
other led has a frequency of 0.5Hz.
On the other hand if we take note to the configurations of the two leds
we will get the following table:
<pre>
out ck
0 0
0 1
1 0
1 1
</pre>
... then the sequence restarts from its beginning.
This is a two bit counter, it count from zero up to three and then
overflows and restarts from zero (wraparound, in technicalese).

Using more breadboards it is possible to implement counters using more
bits. The divisors must be chained: the LSB of the counter is a master
clock of a board, connect it to the ck input on the same board and
you will get the second-LSB of the result. Then connect the out of this board
to the ck of the following one and so on up to the number of bits of the
counter. Three breadboards permit to implement a four bit counter.

[[File:chaineddivisor.jpg]]

The first out signal provides divides the frequency of the clock by two,
and in the same way all the other divisors further divide the resulting
frequency by two.

The output of this circuit can be visualized by the following table:
<pre>
o3 o2 o1 o0=ck
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1
</pre>

A four traces oscilloscope would show the following traces:

[[File:divisoroscilloscope.jpg]]

No more secrets Part 10: Synchronous memory

2014-10-18T13:34:35Z

GiuliaN:

The computational circuits generate a binary output depending (only) on
the value of their inputs. These circuits are called combinatorial
circuit because their output does not depend on the time. Providing them
with a specific input data configuration, they give the same result.
Oue ALU is an example of combinatorial circuit: for a given configuration
ot its input pins (data and control pins) it always generates the sale
output.

A closer look of a combinatorial circuit would reveal that it need a bit
of time to converge to its result, the time neede by all the logical gates
to switch to their new status.

A memory to store the current status is the trick to generate sequential
circuits. The current status is used by the combinatorial circuits to
compute the next status which is stored in the memory for the next step.

In order for this circuit to work properly, the status storage circuit
must be composed by cells able to store the new status and to give the
old status at the same time, otherwise the output of the current
computation could be erroneously taken immediately as input of the
computation itself. So if the combinatorial circuit, for example, adds
one to the former status, the new value could be taken erroneously as
input and add two, three, etc. resulting in a unpredictable result.
It would play like an orchestra without a director.

This is the goal of the master-slave flip-flop (MSFF).
Here is the schematics of a MSFF. (The reset part is optional. It will be
described below.)

[[File:msff.jpg]]

<pre>
in -> A
w(ck) -> ABGG
(notreset -> C)
A -> BE
B -> F (or B -> C)
(C -> DD)
(D -> F)
E -> FH
F -> EI
G -> HI
H -> J
I -> K
J -> K out
K -> J
</pre>

This circuit is composed by two latches. The first (composed by gates
E and F) is storing the new value when ck is one, the second (gates J and
K) copies the value of the first latch when ck drops to zero.

In this way, when ck is one the combinatorial circuit can compute a new
value which is stored in the first latch. In fact, when ck is one the two
latches are insulated and can have different values stored. So, status
changes made by the combinatorial circuit are stored in the first latch
but cannot be propagated again in the combinatorial circuit as inputs.
In other words, the input of the combinatorial circuit is stable.

When ck switches to zero the value of the first latch becomes stable and
is copied in the second latch. When ck is zero, the input in of the
MSFF is ignored.

The optional circuit composed by gates C and D adds an input pin to reset
the flip-flop. Our MSFF workd properly when the pin notreset is one, i.e.
it is connected to the positive rail of the breadboard.

If notreset is temporarily set to zero our MSFF value is reset to zero.
This pin can be used to force the MSFF to have value zero when the circuit
is powered up. Without this circuit, a flip-flop, and in general any latch,
has an initial random value, zero or one, depending on which gate of the
latch converges first.
Many circuts can have random initial values, but some do not.
It is the case, for example, of the program counter, the register which
stores the address of the next instruction to be executed.
A register in our CPU is an array of MSFF.
This register must have a pre-determined value at startup; zero can be
a good choice.

If we connect the notreset pin to a circuit like the following one:

[[File:resetschematics.jpg]]

our flip-flop will always have out equals to one when the circuit is turned
on. In fact, at startup notreset will be zero until the capacitor has been
charged to the one level and then it will be one forever.

To test our MSFF connect the notreset pin to one (or to the circuit above
if you have implemented it). Then connect two leds at the outputs of gates
E and J and buttons conencted to in and ck(w).
Now, decide which value you want to store in our FF. If it is one push the
button connected to in, otherwise leave it unpushed. Now, keeping the in
button in that state, push the ck(w) button and keep it pressed for a while
to better understand how this circuit works. You should see the value
connected to the E gate chenging its state to assume the same value as in.
The led connected to the E gate showd the status of the first latch, it has
been added just for educational purposes, it is not a real output of the
system. The value of out is shown by the led connected to the J gate,
this value does not change while ck(w) is one.

When the button connected to ck(w) is released, the value of the first
latch is copied to the second, so the output led (connected to gate J)
gets the same status of the other led.

You can also connect the ck(w) the master clock and a third led to the
output of the clock. You will see that the input provided by the in button
is copied in the master latch (gates EF) when the clock is one and then to
the slave latch (JK) when the clock shitches to zero.

No more secrets Part B: Is it zero?

2014-10-16T16:34:45Z

GiuliaN:

This module checks if the result of a computation is zero or not.
The output of the circuit is one if all its input lines are zero.
Viceversa, if one of its input has value one, the output is zero.

It is an implementation of a four inputs NOR gate.

This is the circuit:

[[File:PartB.png]]

and this is the map for jumpers:

<pre>
i0 -> AA
i1 -> BB
i2 -> EE
i3 -> FF
A -> C
B -> C
C -> DD
D -> I
E -> G
F -> G
G -> HH
H -> I
I -> outnotZ JJ
J -> outZ
</pre>

notZ output is just for testing. When a led is connected to this line
the entire circuit is a four inputs OR gate, so the led turns on when
at least one of the input line is one.
outZ is the result of a NOR gate so it has the opposite behavior: a led
diode connected to outZ lits when all the inputs are zero and it get
turned off as soon as at least one input has the value one.

File:PartB.png

2014-10-16T16:32:50Z

GiuliaN:

No more secrets Part E: Shift to Multiply and Divide

2014-10-15T12:33:17Z

GiuliaN:

This is a left shift circuit for three bits:

[[File:leftshift.jpg]]

and the jumper table:

<pre>
in3 -> A
in2 -> BD
in1 -> EG
in0 -> JH
SL -> BEH
NSL -> ADGJ
A -> C
B -> C
C -> out3
D -> F
E -> F
F -> out2
G -> I
H -> I
I -> out1
J -> KK
K -> out0
</pre>

To test this circuit exactly one of the inputs SL or NSL must be set to
one. When NSL is one the 4 input bits are copied to the outputs.
When SL is one in0 is copied to out1, in1 to out2, in2 to out3 and out0 is
zero. If we give to the four input bits the meaning of the binary
representation of a number, when SL is one the result is the input times
two. The result is correct both for signed and unsigned numbers provided
the result can be stored in four bits.

For esample:
<pre>
leftshift(3) = leftshift(0011) = 0110 = 6 (both for unsigned and signed numbers)

leftshift(5) = leftshift(0101) = 1010 = 10 (unsigned only!)

leftshift(-3) = leftshift(1101) = 1010 = -6 (signed)
</pre>

It is possible to test the circuit in this way: plug four leds on the
output and connect NSL to one (positive rail). Now set a random input
configuration, you'll see the same configuration in the pattern of
leds. Moving the jumper from NSL to SL the led pattern will move (left) and the
least significant bit will be zero.

A right shift circuit can divide values by two in a similar manner.
Unfortunately, in this case signed and unsigned numbers must be processed
in a different way.

This is the circuit:

[[File:rightshift.jpg]]

and the jumper table:
<pre>
in3 -> AC
in2 -> DF
in1 -> GI
in0 -> J
SR -> CFI
NSR -> DGJ
copy3 -> A
A -> BB
B -> out3
C -> E
D -> E
E -> out2
F -> H
G -> H
H -> out1
I -> K
J -> K
K -> out0
</pre>

Now the valid configurations for SR, NSR and copy3 are the following ones:
<pre>
SR NSR copy3
0 1 1 copy all the inputs in the corrisponding outputs
1 0 0 shift right for unsigned (the MSB is zero)
(also known as logical shift)
1 0 1 shift right for signed (the MSB is copied)
(A.K.A. arithmetic shift)
</pre>

The difference between a logical shift and an arithmetic shift is the
management of the Most Significant Bit (MSB, i.e. out3):
a logical shift resets it to zero while an arithmetic shift copies the
former value of the MSB, out2 and out3 has always the same value in
an arithmetic shift.
In other words, an arithmetic shift keeps the sign bit unchanged.

A logical right shift is a division by two operation for unsigned integers.
An arithmentic right shift is a division by two only for positive integers
and for even negative numbers. For odd negative numbers the result is
rounded downwards, so incorrect.

<pre>
(any kind of right shift, logical or arithmetic).
rightshift(3) = leftshift(0110) = 0011 = 3
(both for unsigned and signed numbers)

logical_rightshift(10) = logical_rightshift(1010) =
= 101 = 5 (unsigned only!)

arithmetic_rightshift(-6) = arithmetic_rightshift(1010) =
= 1101 = -3 (signed)

arithmetic_rightshift(-3) = arithmetic_rightshift(1101) =
= 1110 = -2 (signed)
</pre>

A complete and flexible shifter can be implemented using three breadboards.

[[File:completeshifter.jpg]]

The shift control circuit has two control bits sh0 and sh1 supporting
the following configurations:
<pre>
sh1 sh0
0 0 do not shift
0 1 left shift
1 0 (logical) right shift
1 1 arithmetic right shift
</pre>

This is the circuit and the map for the jumpers:

[[File:shiftcontrol.jpg]]

<pre>
sh1 -> AABC outSR
sh0 -> BD
A -> outNSR
B -> CD
C -> outcopy3
D -> EE outNSL
E -> outSL
</pre>

No more secrets Part E: Shift to Multiply and Divide

2014-10-15T09:05:42Z

GiuliaN:

This is a left shift circuit for three bits:

[[File:leftshift.jpg]]

and the jumper table:

<pre>
in3 -> A
in2 -> BD
in1 -> EG
in0 -> JH
SL -> BEH
NSL -> ADGJ
A -> C
B -> C
C -> out3
D -> F
E -> F
F -> out2
G -> I
H -> I
I -> out1
J -> KK
K -> out0
</pre>

To test this circuit exactly one of the inputs SL or NSL must be set to
one. When NSL is one the 4 input bits are copied to the outputs.
When SL is one in0 is copied to out1, in1 to out2, in2 to out3 and out0 is
zero. If we give to the four input bits the meaning of the binary
representation of a number, when SL is one the result is the input times
two. The result is correct both for signed and unsigned numbers provided
the result can be stored in four bits.

For esample:
<pre>
leftshift(3) = leftshift(0011) = 0110 = 6 (both for unsigned and signed numbers)

leftshift(5) = leftshift(0101) = 1010 = 10 (unsigned only!)

leftshift(-3) = leftshift(1101) = 1010 = -6 (signed)
</pre>

It is possible to test the circuit in this way: plug four leds on the
output and connect NSL to one (positive rail). Now set a random input
configuration, you'll see the same configuration in the pattern of
leds. Moving the jumper from NSL to SL the led pattern will move (left) and the
least significant bit will be zero.

A right shift circuit can divide values by two in a similar manner.
Unfortunately, in this case signed and unsigned numbers must be processed
in a different way.

This is the circuit:

[[File:rightshift.jpg]]

and the jumper table:
<pre>
in3 -> AC
in2 -> DF
in1 -> GI
in0 -> J
SR -> CFI
NSR -> DGJ
copy3 -> A
A -> BB
B -> out3
C -> E
D -> E
E -> out2
F -> H
G -> H
H -> out1
I -> K
J -> K
K -> out0
</pre>

Now the valid configurations for SR, NSR and copy3 are the following ones:
<pre>
SR NSR copy3
0 1 1 copy all the inputs in the corrisponding outputs
1 0 0 shift right for unsigned (the MSB is zero)
(also known as logical shift)
1 0 1 shift right for signed (the MSB is copied)
(A.K.A. arithmetic shift)
</pre>

The difference between a logical shift and an arithmetic shift is the
management of the Most Significant Bit (MSB, i.e. out3):
a logical shift resets it to zero while an arithmetic shift copies the
former value of the MSB, out2 and out3 has always the same value in
an arithmetic shift.
In other words, an arithmetic shift keeps the sign bit unchanged.

A logical right shift is a division by two operation for unsigned integers.
An arithmentic right shift is a division by two only for positive integers
and for even negative numbers. For odd negative numbers the result is
rounded downwards, so incorrect.

<pre>
(any kind of right shift, logical or arithmetic).
rightshift(3) = leftshift(0110) = 0011 = 3
(both for unsigned and signed numbers)

logical_rightshift(10) = logical_rightshift(1010) =
= 101 = 5 (unsigned only!)

arithmetic_rightshift(-6) = arithmetic_rightshift(1010) =
= 1101 = -3 (signed)

arithmetic_rightshift(-3) = arithmetic_rightshift(1101) =
= 1110 = -2 (signed)
</pre>

A complete and flexible shifter can be implemented using three breadboards.

[[File:completeshifter.jpg]]

The shift control circuit has two control bits sh0 and sh1 supporting
the following configurations:
<pre>
sh1 sh0
0 0 do not shift
0 1 left shift
1 0 (logical) right shift
1 1 arithmetic right shift
</pre>

This is the circuit and the map for the jumpers:

[[File:shiftcontrol.jpg]]

<pre>
sh1 -> AABC outSR
sh0 -> BDEE
A -> outNSR
B -> CD
C -> outcopy3
D -> EE outNSL
E -> outSL
</pre>

No more secrets Part E: Shift to Multiply and Divide

2014-10-15T08:46:36Z

GiuliaN:

This is a left shift circuit for three bits:

[[File:leftshift.jpg]]

and the jumper table:

<pre>
in3 -> A
in2 -> BD
in1 -> EG
in0 -> JH
SL -> BEH
NSL -> ADGJ
A -> C
B -> C
C -> out3
D -> F
E -> F
F -> out2
G -> I
H -> I
I -> out1
J -> KK
K -> out0
</pre>

To test this circuit exactly one of the inputs SL or NSL must be set to
one. When NSL is one the 4 input bits are copied to the outputs.
When SL is one in0 is copied to out1, in1 to out2, in2 to out3 and out0 is
zero. If we give to the four input bits the meaning of the binary
representation of a number, when SL is one the result is the input times
two. The result is correct both for signed and unsigned numbers provided
the result can be stored in four bits.

For esample:
<pre>
leftshift(3) = leftshift(0011) = 0110 = 6 (both for unsigned and signed numbers)

leftshift(5) = leftshift(0101) = 1010 = 10 (unsigned only!)

leftshift(-3) = leftshift(1101) = 1010 = -6 (signed)
</pre>

It is possible to test the circuit in this way: plug four leds on the
output and connect NSL to one (positive rail). Now set a random input
configuration, you'll see the same configuration in the pattern of
leds. Moving the jumper from NSL to SL the led pattern will move (left) and the
least significant bit will be zero.

A right shift circuit can divide values by two in a similar manner.
Unfortunately, in this case signed and unsigned numbers must be processed
in a different way.

This is the circuit:

[[File:rightshift.jpg]]

and the jumper table:
<pre>
in3 -> AC
in2 -> DF
in1 -> GI
in0 -> J
SR -> CFI
NSR -> DGI
copy3 -> A
A -> BB
B -> out3
C -> E
D -> E
E -> out2
F -> H
G -> H
H -> out1
I -> K
J -> K
K -> out0
</pre>

Now the valid configurations for SR, NSR and copy3 are the following ones:
<pre>
SR NSR copy3
0 1 1 copy all the inputs in the corrisponding outputs
1 0 0 shift right for unsigned (the MSB is zero)
(also known as logical shift)
1 0 1 shift right for signed (the MSB is copied)
(A.K.A. arithmetic shift)
</pre>

The difference between a logical shift and an arithmetic shift is the
management of the Most Significant Bit (MSB, i.e. out3):
a logical shift resets it to zero while an arithmetic shift copies the
former value of the MSB, out2 and out3 has always the same value in
an arithmetic shift.
In other words, an arithmetic shift keeps the sign bit unchanged.

A logical right shift is a division by two operation for unsigned integers.
An arithmentic right shift is a division by two only for positive integers
and for even negative numbers. For odd negative numbers the result is
rounded downwards, so incorrect.

<pre>
(any kind of right shift, logical or arithmetic).
rightshift(3) = leftshift(0110) = 0011 = 3
(both for unsigned and signed numbers)

logical_rightshift(10) = logical_rightshift(1010) =
= 101 = 5 (unsigned only!)

arithmetic_rightshift(-6) = arithmetic_rightshift(1010) =
= 1101 = -3 (signed)

arithmetic_rightshift(-3) = arithmetic_rightshift(1101) =
= 1110 = -2 (signed)
</pre>

A complete and flexible shifter can be implemented using three breadboards.

[[File:completeshifter.jpg]]

The shift control circuit has two control bits sh0 and sh1 supporting
the following configurations:
<pre>
sh1 sh0
0 0 do not shift
0 1 left shift
1 0 (logical) right shift
1 1 arithmetic right shift
</pre>

This is the circuit and the map for the jumpers:

[[File:shiftcontrol.jpg]]

<pre>
sh1 -> AABC outSR
sh0 -> BDEE
A -> outNSR
B -> CD
C -> outcopy3
D -> EE outNSL
E -> outSL
</pre>

No more secrets Part E: Shift to Multiply and Divide

2014-10-14T14:26:17Z

GiuliaN:

This is a left shift circuit for three bits:

[[File:leftshift.jpg]]

and the jumper table:

<pre>
in3 -> A
in2 -> BD
in1 -> EG
in0 -> JH
SL -> BEH
NSL -> ADGJ
A -> C
B -> C
C -> out3
D -> F
E -> F
F -> out2
G -> I
H -> I
I -> out1
J -> KK
K -> out0
</pre>

To test this circuit exactly one of the inputs SL or NSL must be set to
one. When NSL is one the 4 input bits are copied to the outputs.
When SL is one in0 is copied to out1, in1 to out2, in2 to out2 and out0 is
zero. If we give to the four input bits the meaning of the binary
representation of a number, when SL is one the result is the input times
two. The result is correct both for signed and unsigned numbers provided
the result can be stored in four bits.

For esample:
<pre>
leftshift(3) = leftshift(0011) = 0110 = 6 (both for unsigned and signed numbers)

leftshift(5) = leftshift(0101) = 1010 = 10 (unsigned only!)

leftshift(-3) = leftshift(1101) = 1010 = -6 (signed)
</pre>

It is possible to test the circuit in this way: plug four leds on the
output and connect NSL to one (positive rail). Now set a random input
configuration, you'll see the same configuration in the pattern of
leds. Moving the jumper from NSL to SL the led pattern will move (left) and the
least significant bit will be zero.

A right shift circuit can divide values by two in a similar manner.
Unfortunately, in this case signed and unsigned numbers must be processed
in a different way.

This is the circuit:

[[File:rightshift.jpg]]

and the jumper table:
<pre>
in3 -> AC
in2 -> DF
in1 -> GI
in0 -> J
SR -> CFI
NSR -> DGI
copy3 -> A
A -> BB
B -> out3
C -> E
D -> E
E -> out2
F -> H
G -> H
H -> out1
I -> K
J -> K
K -> out0
</pre>

Now the valid configurations for SR, NSR and copy3 are the following ones:
<pre>
SR NSR copy3
0 1 1 copy all the inputs in the corrisponding outputs
1 0 0 shift right for unsigned (the MSB is zero)
(also known as logical shift)
1 0 1 shift right for signed (the MSB is copied)
(A.K.A. arithmetic shift)
</pre>

The difference between a logical shift and an arithmetic shift is the
management of the Most Significant Bit (MSB, i.e. out3):
a logical shift resets it to zero while an arithmetic shift copies the
former value of the MSB, out2 and out3 has always the same value in
an arithmetic shift.
In other words, an arithmetic shift keeps the sign bit unchanged.

A logical right shift is a division by two operation for unsigned integers.
An arithmentic right shift is a division by two only for positive integers
and for even negative numbers. For odd negative numbers the result is
rounded downwards, so incorrect.

<pre>
(any kind of right shift, logical or arithmetic).
rightshift(3) = leftshift(0110) = 0011 = 3
(both for unsigned and signed numbers)

logical_rightshift(10) = logical_rightshift(1010) =
= 101 = 5 (unsigned only!)

arithmetic_rightshift(-6) = arithmetic_rightshift(1010) =
= 1101 = -3 (signed)

arithmetic_rightshift(-3) = arithmetic_rightshift(1101) =
= 1110 = -2 (signed)
</pre>

A complete and flexible shifter can be implemented using three breadboards.

[[File:completeshifter.jpg]]

The shift control circuit has two control bits sh0 and sh1 supporting
the following configurations:
<pre>
sh1 sh0
0 0 do not shift
0 1 left shift
1 0 (logical) right shift
1 1 arithmetic right shift
</pre>

This is the circuit and the map for the jumpers:

[[File:shiftcontrol.jpg]]

<pre>
sh1 -> AABC outSR
sh0 -> BDEE
A -> outNSR
B -> CD
C -> outcopy3
D -> EE outNSL
E -> outSL
</pre>

No more secrets Part E: Shift to Multiply and Divide

2014-10-14T14:24:32Z

GiuliaN:

This is a left shift circuit for three bits:

[[File:leftshift.jpg]]

and the jumper table:

<pre>
in3 -> A
in2 -> BD
in1 -> EG
in0 -> JH
SL -> BEH
NSL -> ADGJ
A -> C
B -> C
C -> out3
D -> F
E -> F
F -> out2
G -> I
H -> I
O -> out1
J -> KK
K -> out0
</pre>

To test this circuit exactly one of the inputs SL or NSL must be set to
one. When NSL is one the 4 input bits are copied to the outputs.
When SL is one in0 is copied to out1, in1 to out2, in2 to out2 and out0 is
zero. If we give to the four input bits the meaning of the binary
representation of a number, when SL is one the result is the input times
two. The result is correct both for signed and unsigned numbers provided
the result can be stored in four bits.

For esample:
<pre>
leftshift(3) = leftshift(0011) = 0110 = 6 (both for unsigned and signed numbers)

leftshift(5) = leftshift(0101) = 1010 = 10 (unsigned only!)

leftshift(-3) = leftshift(1101) = 1010 = -6 (signed)
</pre>

It is possible to test the circuit in this way: plug four leds on the
output and connect NSL to one (positive rail). Now set a random input
configuration, you'll see the same configuration in the pattern of
leds. Moving the jumper from NSL to SL the led pattern will move (left) and the
least significant bit will be zero.

A right shift circuit can divide values by two in a similar manner.
Unfortunately, in this case signed and unsigned numbers must be processed
in a different way.

This is the circuit:

[[File:rightshift.jpg]]

and the jumper table:
<pre>
in3 -> AC
in2 -> DF
in1 -> GI
in0 -> J
SR -> CFI
NSR -> DGI
copy3 -> A
A -> BB
B -> out3
C -> E
D -> E
E -> out2
F -> H
G -> H
H -> out1
I -> K
J -> K
K -> out0
</pre>

Now the valid configurations for SR, NSR and copy3 are the following ones:
<pre>
SR NSR copy3
0 1 1 copy all the inputs in the corrisponding outputs
1 0 0 shift right for unsigned (the MSB is zero)
(also known as logical shift)
1 0 1 shift right for signed (the MSB is copied)
(A.K.A. arithmetic shift)
</pre>

The difference between a logical shift and an arithmetic shift is the
management of the Most Significant Bit (MSB, i.e. out3):
a logical shift resets it to zero while an arithmetic shift copies the
former value of the MSB, out2 and out3 has always the same value in
an arithmetic shift.
In other words, an arithmetic shift keeps the sign bit unchanged.

A logical right shift is a division by two operation for unsigned integers.
An arithmentic right shift is a division by two only for positive integers
and for even negative numbers. For odd negative numbers the result is
rounded downwards, so incorrect.

<pre>
(any kind of right shift, logical or arithmetic).
rightshift(3) = leftshift(0110) = 0011 = 3
(both for unsigned and signed numbers)

logical_rightshift(10) = logical_rightshift(1010) =
= 101 = 5 (unsigned only!)

arithmetic_rightshift(-6) = arithmetic_rightshift(1010) =
= 1101 = -3 (signed)

arithmetic_rightshift(-3) = arithmetic_rightshift(1101) =
= 1110 = -2 (signed)
</pre>

A complete and flexible shifter can be implemented using three breadboards.

[[File:completeshifter.jpg]]

The shift control circuit has two control bits sh0 and sh1 supporting
the following configurations:
<pre>
sh1 sh0
0 0 do not shift
0 1 left shift
1 0 (logical) right shift
1 1 arithmetic right shift
</pre>

This is the circuit and the map for the jumpers:

[[File:shiftcontrol.jpg]]

<pre>
sh1 -> AABC outSR
sh0 -> BDEE
A -> outNSR
B -> CD
C -> outcopy3
D -> EE outNSL
E -> outSL
</pre>

No more secrets Part A: A complete ALU

2014-10-12T19:32:26Z

GiuliaN:

An ALU is not just an adder, it is a circuit which is able to perform
several kinds of computations: both Arithmetic and Logic operations.
Our ALU is able to compute sums, subtractions, comparisons, and/or/not
bitwise logical operations, sign change, etc.

An ALU has a number of control input line which select the operation,
two sets of input lines (two buses) for the operands and an output bus
for the result.

The implementation of our ALU requires three breadboard per bit plus
two breadboard for zero and overflow detection.
A complete four-bit ALU then requires 14 breadboards, a three-bit ALU
just 11. Zero and overflow detection circuits are optional.

Do not skip this section if you don't have so many breadboards or so many
friends to play with. It is possible to test each block separately and
use your imagination to envision how the entire structure behaves.

Each bit of our ALU is composed by a three breadboards: a full adder,
a two-control bits multiplexer and the logical unit. We have already
presented the two former circuits, the latter one is presented in the
following part of this chapter.

The block schematics is the following one:

[[File:ALU1bit.jpg]]

Several 1-bit ALUs can be connected/chained together.
It is possible to add an overflow and a zero check circuits.

[[File:ALU4bit.jpg]]

The logical unit selects which inputs are used in the computation and
performs some logical computations: 'and', 'or'.

The schematics of our logical unit is in the following picture:

[[File:logical.jpg]]

This is the map of the jumpers:

<pre>
inA -> A
enA -> A
inB -> B
enB -> B
invB -> CE
A -> GGK
B -> CD
C -> DE
D -> F
E -> F
F -> HHK
G -> I,outA
H -> I,outB
I -> JJ
J -> outAND
K -> outOR
</pre>

This circuit has two data inputs: inA and inB. These inputs get the
value of two corresponding bits to be processed.

There are three control input bits: enA, enB and invB.
The prefix 'en' means 'enable': if enA is zero the value of inA is
ignored, discared, i.e. inA is taken into consideration for the computation
only when enA is true. When enA is zero the first operand of the full
adder, of the 'and' operation , of the 'or' operator is zero.
Similarly enB is the enable bit for inB. When invB is one the value of B
is negated. So when enB is 1 the input for the second operand of the full
adder and of the logical operators (and, or) is B, or not B when invB is 1.
If enB is zero, the input of that second operand has the same value of invB.

So, outA and outB have been pre-processed to be the inputs of the full adder.

<pre>
inA inB invB outA outB outAND outOR
0 0 0 0 0 0 0
0 0 1 0 1 0 1
0 1 0 0 B 0 B
0 1 1 0 notB 0 notB
1 0 0 A 0 0 A
1 0 1 A 1 A A
1 1 0 A B AandB AorB
1 1 1 A notB Aand(notB) Aor(notB)
</pre>

No more secrets Part 9: An adder can subtract, too

2014-10-09T14:22:56Z

GiuliaN:

Now we can add positive and negative numbers.
Do we need a specific circuit to compute subtraction? The answer is again
"almost no". All what we need is a circuit able to compute the
ones' complement of a number, i.e. able to flip all the bit values of a
number, all the zeros become ones and viceversa.

The trick is the following: if we add the minuend to the ones' complement
of the subtrahend and we further add one, we get the difference.

We can see this from another point of view, if we add one to the one's
complement of a number we get its opposite.
<pre>
0100 is 4
1011 is the one's complement of 0100
adding one the result is:
1100 which is -4

1001 is -7
0110 is the one's complement of 1001
adding one the result is:
0111 which is 7
</pre>

So, the 'trick' adds the opposite of the subtrahend to the minuend.

Not surprisingly the 'trick' works for both signed and unsigned numbers.

<pre>
unsigned
4 - 2 = 0100 - 0010 = 0100 + 1101 + 1 = (1)0010 = 2
10 - 3 = 1010 - 0011 = 1010 + 1100 + 1 = (1)0111 = 7
13 - 3 = 1101 - 0011 = 1101 + 0100 + 1 = (1)1010 = 10
signed
4 - 2 = 0100 - 0010 = 0100 + 1101 + 1 = (1)0010 = 2
-3 - 3 = 1101 - 0011 = 1101 + 0100 + 1 = (1)1010 = -6
-3 -(-3) = 1101 - 1101 = 1101 + 0010 + 1 = (1)0000 = 0
</pre>

In order to use a chain of full adders to compute substractions we need:
* to supply the ones' complement of the second operand
* to set the Cin of the MSB adder to one (this will be the extra 1 added
in to the one's complement).

If we set the input lines as just described, the output line provides the
correct value of the difference.

The same circuit can be used to compare numbers, too.
In fact if we subtract unsigned numbers, the result is meaningful only when
the minuend is larger than the subtrahend. In this case the Cout of the
MSB adder is one, otherwise it is zero.
So, if we set up the circuit to compute the difference X - Y and we consider
only the Cout of the MSB: Cout is 1 if X >= Y, Cout is 0 otherwise.

<pre>
X=10 Y=3
10 - 3 = 1010 - 0011 = 1010 + 1100 + 1 = (1)0111 Cout is 1: 10 >= 3
10 - 10 = 1010 - 1010 = 1010 + 0101 + 1 = (1)0000 Cout is 1: 10 >= 10
3 - 10 = 0011 - 1010 = 0011 + 0101 + 1 = (0)1001 Cout is 0: 3 < 10
(the result, 9 is wrong, as 3 - 10 cannot be represented as unsigned number!)
</pre>

It is possible to compare signed numbers too, but the situation is a bit
more complex. In this case X < Y if the result of a XOR between the signed
overflow and the value of the MSB of the result is one (the signed overflow
itself is the result of a XOR between the Cout and the Cin of the MSB).

This definition gives the correct result even in case of overflow of the
subtraction.

Maybe some examples can help to understand the rule:
<pre>
A=4 B=6 unsigned: 0100 - 0110 = 0100 + 1001 + 1 = (0)1110
Cout=0 so A < B
A=4 B=6 signed 0100 - 0110 = 0100 + 1001 + 1 = (0)1110
100 + 001 + 1 = (0)110
overflow=0 MSB=1 Cout XOR MSB=1 so A<B

A=10 B=3 unsigned: 1010 - 0011 = 1010 + 1100 + 1 = (1)0111
Cout=1 so A >= B
A=-6 B=3 signed 1010 - 0110 = 1010 + 1100 + 1 = (1)0111
010 + 100 + 1 = (0)111
overflow=1 MSB=0 Cout XOR MSB=1 so A<B
Note that 10 as a signed 4 bit number and -6 as signed number have
the same representation.

A=12 B=14 unsigned: 1100 - 1110 = 1100 + 0001 + 1 = (0)1110
Cout=0 so A < B
A=-4 B=-2 signed: 1100 - 1110 = 1100 + 0001 + 1 = (0)1110
100 + 001 + 1 = (0)110
overflow=0 MSB=1 Cout XOR MSB=1 so A<B

A=7 B=10 unsigned: 0110 - 1010 = 0110 + 0101 + 1 = (0)1100
Cout=0 so A < B
A=7 B=-6 signed: 0110 - 1010 = 0110 + 0101 + 1 = (0)1100
110 + 101 + 1 = (1)100
overflow=1 MSB=1 Cout XOR MSB=0 so A>=B
</pre>

No more secrets Part 9: An adder can subtract, too

2014-10-09T14:20:28Z

GiuliaN:

Now we can add positive and negative numbers.
Do we need a specific circuit to compute subtraction? The answer is again
"almost no". All what we need is a circuit able to compute the
ones' complement of a number, i.e. able to flip all the bit values of a
number, all the zeros become ones and viceversa.

Thr trick is the following: if we add the minuend to the ones' complement
of the subtrahend and we further add one, we get the difference.

We can see this from another point of view, if we add one to the one's
complement of a number we get its opposite.
<pre>
0100 is 4
1011 is the one's complement of 0100
adding one the result is:
1100 which is -4

1001 is -7
0110 is the one's complement of 1001
adding one the result is:
0111 which is 7
</pre>

So, the 'trick' adds the opposite of the subtrahend to the minuend.

Not surprisingly the 'trick' works for both signed and unsigned numbers.

<pre>
unsigned
4 - 2 = 0100 - 0010 = 0100 + 1101 + 1 = (1)0010 = 2
10 - 3 = 1010 - 0011 = 1010 + 1100 + 1 = (1)0111 = 7
13 - 3 = 1101 - 0011 = 1101 + 0100 + 1 = (1)1010 = 10
signed
4 - 2 = 0100 - 0010 = 0100 + 1101 + 1 = (1)0010 = 2
-3 - 3 = 1101 - 0011 = 1101 + 0100 + 1 = (1)1010 = -6
-3 -(-3) = 1101 - 1101 = 1101 + 0010 + 1 = (1)0000 = 0
</pre>

In order to use a chain of full adders to compute substractions we need:
* to supply the ones' complement of the second operand
* to set the Cin of the MSB adder to one (this will be the extra 1 added
in to the one's complement).

If we set the input lines as just described, the output line provides the
correct value of the difference.

The same circuit can be used to compare numbers, too.
In fact if we subtract unsigned numbers, the result is meaningful only when
the minuend is larger than the subtrahend. In this case the Cout of the
MSB adder is one, otherwise it is zero.
So, if we set up the circuit to compute the difference X - Y and we consider
only the Cout of the MSB: Cout is 1 if X >= Y, Cout is 0 otherwise.

<pre>
X=10 Y=3
10 - 3 = 1010 - 0011 = 1010 + 1100 + 1 = (1)0111 Cout is 1: 10 >= 3
10 - 10 = 1010 - 1010 = 1010 + 0101 + 1 = (1)0000 Cout is 1: 10 >= 10
3 - 10 = 0011 - 1010 = 0011 + 0101 + 1 = (0)1001 Cout is 0: 3 < 10
(the result, 9 is wrong, as 3 - 10 cannot be represented as unsigned number!)
</pre>

It is possible to compare signed numbers too, but the situation is a bit
more complex. In this case X < Y if the result of a XOR between the signed
overflow and the value of the MSB of the result is one (the signed overflow
itself is the result of a XOR between the Cout and the Cin of the MSB).

This definition gives the correct result even in case of overflow of the
subtraction.

Maybe some examples can help to understand the rule:
<pre>
A=4 B=6 unsigned: 0100 - 0110 = 0100 + 1001 + 1 = (0)1110
Cout=0 so A < B
A=4 B=6 signed 0100 - 0110 = 0100 + 1001 + 1 = (0)1110
100 + 001 + 1 = (0)110
overflow=0 MSB=1 Cout XOR MSB=1 so A<B

A=10 B=3 unsigned: 1010 - 0011 = 1010 + 1100 + 1 = (1)0111
Cout=1 so A >= B
A=-6 B=3 signed 1010 - 0110 = 1010 + 1100 + 1 = (1)0111
010 + 100 + 1 = (0)111
overflow=1 MSB=0 Cout XOR MSB=1 so A<B
Note that 10 as a signed 4 bit number and -6 as signed number have
the same representation.

A=12 B=14 unsigned: 1100 - 1110 = 1100 + 0001 + 1 = (0)1110
Cout=0 so A < B
A=-4 B=-2 signed: 1100 - 1110 = 1100 + 0001 + 1 = (0)1110
100 + 001 + 1 = (0)110
overflow=0 MSB=1 Cout XOR MSB=1 so A<B

A=7 B=10 unsigned: 0110 - 1010 = 0110 + 0101 + 1 = (0)1100
Cout=0 so A < B
A=7 B=-6 signed: 0110 - 1010 = 0110 + 0101 + 1 = (0)1100
110 + 101 + 1 = (1)100
overflow=1 MSB=1 Cout XOR MSB=0 so A>=B
</pre>

No more secrets Part 6: Let us play together

2014-10-08T11:11:56Z

GiuliaN:

The circuits presented in the previous sections can be implemented on a
single breadboard. In this section we will see how to connect several
breadboards together to build larger, more complex circuits.

If you have two bradboard, or you meet a friend of yours who likes this
booklet and has another breadboard, it is possible to build a complete two
control bit demux.

Build the two demux circuit illustrated in the previous section on
both breadboards and then connect them together as illustrated here below.

[[File:demux2boards.jpg]]

Only one of the demux(es) in boardA is actually used.
When both c0 and c1 have value 0 then in is copied to out00,
and so on as it is summarized in the following table:
<pre>
c1 c0
0 0 in is copied to out00
0 1 in is copied to out01
1 0 in is copied to out10
1 1 in is copied to out11
</pre>

To build a three control bit demux (eight output lines) more breadboards
(or more friends) are needed. The following picture shows how four
breadboards all set up as two demux circuits (as seen in the previous
chapter) can be connected to form a three control bit demux.

[[File:demux4boards.jpg]]

Three breadboards can be used to build a three control bit decoder.
The first board must be configured as a twi bit decoder and both the others
as demux (2x1bit demux).
All you need is then to connect the boards as follows:

[[File:decoder3boards.jpg]]

<pre>
in0 in1 in2 Enabled output
0 0 0 out00 muxA
0 0 1 out01 muxA
0 1 0 out10 muxA
0 1 1 out11 muxA
1 0 0 out00 muxB
1 0 1 out01 muxB
1 1 0 out10 muxB
1 1 1 out11 muxB
</pre>

An eight input/three output lines priority encoder requires three
breadboards, two of them configured as four inputs/2 outputs priority
encoders while the third needs a custom circuit to combine the
partial results.

[[File:prioencoder3boards.jpg]]

The V output bit of the highest 4/2 prio encoder is the new most significant
bit of the output. This v bit drives two 1-bit mutexes. When V of the
highest priority encoder, its out1 and out0 output are copied to the global
out1 and out0 results. If V is false, the output value of the lowest
priority encored are copied instead.
The global V (valid) bit output is one when at least one V bit of the
2 bit encoders is one, in fact it is the result of an OR gate.

If you have many boards (or many friends), it is possible to build a
sixteen data/four control bit multiplex using five breadboard, all
set up as four inputs/two control bits boards.
The following schematics shows how to connect the boards:

[[File:mux5boards.jpg]]

No more secrets Part 5: Mux Demux

2014-10-07T08:37:18Z

GiuliaN: /* The Demux */

== The MUX (or Selector) ==

The Multiplexer (also called Mux or Selector by closer friends) is a circuit which has n control inputs, 2^n data inputs and one output.

The control input decides which data input is copied into the output all the other inputs are simply ignored.

In my mind a Mux is similar to a track switch on a railroad. More specifically it reminds the switching system for the trains leaving a station. There are plenty of platforms in the station and the switches must be set up for the departing train to guarantee the routing to the railroad to the next station

[[File:railswitch1.jpg]]

The truth table for a mux having two control inputs is the following
<pre>
c1 c0 in0 in1 in2 in3 out
0 0 0 x x x 0
0 0 1 x x x 1
0 1 x 0 x x 0
0 1 x 1 x x 1
1 0 x x 0 x 0
1 0 x x 1 x 1
1 1 x x x 0 0
1 1 x x x 1 1
</pre>
(where x means for any value of this input, both 0 and 1)

The circuit is the following:

[[File:mux.png|400px]]

And this is the file for the jumpers:

<pre>
c0: AACF
c1: HHJ
in0: B
in1: C
in2: E
in3: F
A: BE
B: D
C: D
D: I
E: G
F: G
G: J
H: I
I: K
J: K
K: out
</pre>

For each configuration of in0 and in1 the corresponding input will be copied to the output.
To test this circuit, plug in a led to the output gate (K) and set both c0 and c1 to 0, now the led is turned on and off by setting on and off in0. In other words, in0 is copied on out.
Any input on in1, in2 or in3 does not change the value of out. Now if you set c0 to 1, in1 is copied to out. Now the values at in0 in1 and in3 are irrelevant, while the led turns on and off when the input at in1 changes. Similarly when c0 and c1 are 1 0, in2 is copied and when
c0 and c1 are 1, 1 is the turn of in3.

== The Demux ==

A demultiplexer is the opposite of a mux. It takes one data input and n control inputs and 2^n output lines.
The input is copied on the output line addressed by the control input.

A demux is conceptually similar to a railroad switching system, this time the one that the trains
use entering a station. A train coming from a railroad is routed to a specific track to
reach a specific platform where people can get on and off.

[[File:railswitch2.jpg]]

Unfortunately it needs 14 nand gates to create a two control inputs demux circuits, two more than those available on out breadboard.
However, It is possible to build two 1 control bit demuxes.

This is the circuit:
[[File:demux.png|400px]]

This is the table to set up the jumpers on the breadboard:
<pre>
c0: AAD
in0: BD
c1: FFI
in1: GI
A: B
B: CC
C: out00
D: EE
E: out01
F: G
G: HH
H: out10
I: JJ
J: out11
</pre>

To test this circuit plug in 4 leds to the output lines and connect four buttons to its inputs.
If you push and release the button connected to in0, out00 will turn on and off in the same manner. Now push and keep pressed the button connected to c0. The value of in0 will be copied on out01, I mean now the led on out01 instead of out00.
The same experiment can be done using in1 and c1 as inputs and out10, out11 as outputs.

If you have two breadboards (or a friend has one) and you have both build this circuit it is possible to plug the two boards together and get a 2 control bits (four data outputs) demultiplexer (plus a spare 1bit demux).
Connect out00 and out01 of the first board to in0 and in1 of the second and
connect c0 and c1 together.
The input of in0 of the first board will be routed on out00, out01, out10 and out11 depending on
the value given to in0 of the first board and in0-in1 of the second.

The next chapter will describe in details how the circuits implemented on several breadboard can be connected to obtain more complex circuits.

No more secrets Part 5: Mux Demux

2014-10-06T08:48:00Z

GiuliaN:

== The MUX (or Selector) ==

The Multiplexer (also called Mux or Selector by closer friends) is a circuit which has n control inputs, 2^n data inputs and one output.

The control input decides which data input is copied into the output all the other inputs are simply ignored.

In my mind a Mux is similar to a track switch on a railroad. More specifically it reminds the switching system for the trains leaving a station. There are plenty of platforms in the station and the switches must be set up for the departing train to guarantee the routing to the railroad to the next station

[[File:railswitch1.jpg]]

The truth table for a mux having two control inputs is the following
<pre>
c1 c0 in0 in1 in2 in3 out
0 0 0 x x x 0
0 0 1 x x x 1
0 1 x 0 x x 0
0 1 x 1 x x 1
1 0 x x 0 x 0
1 0 x x 1 x 1
1 1 x x x 0 0
1 1 x x x 1 1
</pre>
(where x means for any value of this input, both 0 and 1)

The circuit is the following:

[[File:mux.png|400px]]

And this is the file for the jumpers:

<pre>
c0: AACF
c1: HHJ
in0: B
in1: C
in2: E
in3: F
A: BE
B: D
C: D
D: I
E: G
F: G
G: J
H: I
I: K
J: K
K: out
</pre>

For each configuration of in0 and in1 the corresponding input will be copied to the output.
To test this circuit, plug in a led to the output gate (K) and set both c0 and c1 to 0, now the led is turned on and off by setting on and off in0. In other words, in0 is copied on out.
Any input on in1, in2 or in3 does not change the value of out. Now if you set c0 to 1, in1 is copied to out. Now the values at in0 in1 and in3 are irrelevant, while the led turns on and off when the input at in1 changes. Similarly when c0 and c1 are 1 0, in2 is copied and when
c0 and c1 are 1, 1 is the turn of in3.

== The Demux ==

A demultiplexer is the opposite of a mux. It takes one data input and n control inputs and 2^n output lines.
The input is copied on the output line addressed by the control input.

A demux is conceptually similar to a railroad switching system, this time the one that the trains
use entering a station. A train coming from a railroad is routed to a specific track to
reach a specific platform where people can get on and off.

[[File:railswitch2.jpg]]

Unfortunately it needs 14 nand gates to create a two control inputs demux circuits, two more than those available on out breadboard.
However, It is possible to build two 1 control bit demuxes.

This is the circuit:
[[File:demux.png|400px]]

This is the table to set up the jumpers on the breadboard:
<pre>
c0: AAD
in0: BD
c1: FFI
in1: GH
A: B
B: CC
C: out00
D: EE
E: out01
F: G
G: HH
H: out10
I: JJ
J: out11
</pre>

To test this circuit plug in 4 leds to the output lines and connect four buttons to its inputs.
If you push and release the button connected to in0, out00 will turn on and off in the same manner. Now push and keep pressed the button connected to c0. The value of in0 will be copied on out01, I mean now the led on out01 instead of out00.
The same experiment can be done using in1 and c1 as inputs and out10, out11 as outputs.

If you have two breadboards (or a friend has one) and you have both build this circuit it is possible to plug the two boards together and get a 2 control bits (four data outputs) demultiplexer (plus a spare 1bit demux).
Connect out00 and out01 of the first board to in0 and in1 of the second and
connect c0 and c1 together.
The input of in0 of the first board will be routed on out00, out01, out10 and out11 depending on
the value given to in0 of the first board and in0-in1 of the second.

The next chapter will describe in details how the circuits implemented on several breadboard can be connected to obtain more complex circuits.

No more secrets Part 4: Encode and Decode...

2014-10-01T15:43:06Z

GiuliaN:

Actually it is the reverse way round, let us decode first and encode then.

== A decoder ==

A decoder is a circuit having n input lines and 2^n (2 elevated to the n-th
power) output lines.

Each output is true for a specific configuration of the input.

We will implement a 2/4 decoder, i.e. a decoder having 2 inputs and
four outputs.

This is its truth table:
<pre>
IN1 IN0 OUT0 OUT1 OUT2 OUT3
0 0 1 0 0 0
0 1 0 1 0 0
1 0 0 0 1 0
1 1 0 0 0 1
</pre>

The circuit to implement the decoder is the following:

[[File:decoder.png|600px]]

And this is the table you can use to set up the jumpers on your
breadboard:

<pre>
IN0->BBEI
IN1->AAGI
A->CE
B->CG
C->DD
D->out0
E->FF
F->out1
G->HH
H->out2
I->JJ
J->out3
</pre>

To test this circuit, connect a led on each output line.
Initially the led on out0 is on, the others off.
In fact out0 is 1 when the input configration is 0,0.
Now connect in0, in1 or both to the positive line. These configuration
should turn on the leds at out1, out2 and out3, respectively, one at
at a time.

== A priority Encoder ==

An encoder is the reverse circuit of a decoder: it has 2^n input lines and
n output lines.

A "normal" encoder should permit only input configurations in which exactly
one input line is one, the others being zero.
A 4/2 encoder has the following truth table:
<pre>
IN3 IN2 IN1 IN0 OUT1 OUT0
0 0 0 1 0 0
0 0 1 0 0 1
0 1 0 0 1 0
1 0 0 0 1 1
</pre>

Any other input configuration should not be permitted.

A priority encoder is an extension of an encoder.
It has 2^n input, n+1 output lines: n of them are the input encoding and
one is the valid configuration bit (V) which is one if at least 1 bit in input
is one.
Each bit represents a priority, when the input configuration is valid (V is 1)
the output is the highest priority bit which is 1 encoded in binary.

A truth table can help to understand this concept.

<pre>
IN3 IN2 IN1 IN0 OUT1 OUT0 V
0 0 0 0 0 0 0
0 0 0 1 0 0 1
0 0 1 0 0 1 1
0 0 1 1 0 1 1
0 1 0 0 1 0 1
0 1 0 1 1 0 1
0 1 1 0 1 0 1
0 1 1 1 1 0 1
1 0 0 0 1 1 1
1 0 0 1 1 1 1
1 0 1 0 1 1 1
1 0 1 1 1 1 1
1 1 0 0 1 1 1
1 1 0 1 1 1 1
1 1 1 0 1 1 1
1 1 1 1 1 1 1
</pre>

When the IN2 is 1 and none of the input having higher priority than IN2
(i.e. IN3) is 1, the output is 1 0 (2 coded in binary).
If IN0, IN1 or IN3has the highest priority "1" in the configuration the output
is 0 0, 0 1 or 1 1 (the encoding of 0,1 or 3) respectively.

This is the circuit and the mapping for the jumpers

[[File:priencoder.png|600px]]

<pre>
IN3->AA
IN2->BB
IN1->FFD
IN0->GG
A->CE
B->CD
C->II out1
D->E
E->out0
F->H
G->H
H->JJ
I->K
J->K
K->outV
</pre>

If the circuit works properly, in its starting state, i.e. when all inputs are 0, all
outputs should be 0.
As usual connect led diodes on the output lines.
The output bit V should be 1 when any of the input is one (it works
as a 4 inputs OR gate).
Try then some configurations from the table above and you'll see the
right encoding appears on the output leds.

No more secrets Part 2: Let us build the experimental board

2014-05-26T20:53:26Z

GiuliaN:

== Ingredients ==

* #1 Standard Breadboard (63 rows, 5+5 holes for row, power and ground rails
on both sides)
* #25 BC547 transistors
* #24 10Kohm 1/4W resistors (colors: brown=1 black=0 orange=10^3 gold=5%)
* #14 330ohm 1/4W resistors (colors: orange=3 orange=3 brown=10^1 gold=5%)
* #4 led diodes (Red, 5mm are okay)
* #2 electrolyctic capacitors 10uF (microfarad) 16V
* #1 5V power supply (the tool uses at most 250mA) (instead of a power supply you may consider using a battery holder for three or four AA batteries, everything should work at 4.5 or 6V).
* #1 set of jumpers for breadboards.
* #23 0.3" jumpers

A piece of old multi pair telephone wire can be used to create the
jumpers, both the 0.3" wide and the longer ones to build the experiments.

Tools needed: cable cutter or a pair of strong scissors. If you have a wire
stripper it is useful, although not strictly needed.

[[File:Board.jpg|600px]]

If you like, it is clearer during the experiments to provide the inputs
using buttons instead of moving jumpers. In order to build a keypad for the
input you need:
* #1 another breadboard (maybe smaller than the one above, I'm using a 30
rows one)
* #5 or more buttons for breadboards
* #5 jumpers (which can be created using the old telephone cable).

[[File:Keypad.jpg|600px]]

The board(s) implements:
* #1 1Hz master clock
* #11 NAND gates
* ... and #5 buttons on the second board

=== How to build the master clock ===

Schematics of the unit (already discussed in
[[No_more_secrets_in_your_CPU:_Part_1]]|Part1):

[[File:Clock.png|600px]]

For this unit you will need:
* #3 transistors
* #3 330ohm resistors (orange-orange-brown)
* #2 10Kohm resistors (brown-black-orange)
* #2 10uF capacitors
* #4 0.3" jumpers

[[File:clock1hz.jpg|600px]]

Fold the pins of the resistors and trim their length 10 about 1cm as
illustrated below:

[[File:resistorx.png|100px]][[File: resistorsnapshot.jpg|200px]]

Resistors are not polarized (provided that the pins are connected
in the right positions of the breadboard, you don't need to pay
attention on which end is which).

BC547 transistors are not cylindrical, they are flat on one side
(usually there is the sign BC547 on that flat side).
In order to recognize the three pins of a transitor (collector, base and
emitter) you have to keep the transistor having the flat face towards you:
in this position the three pins are C,B,E collector, base and emitter.
(This is specific for BC547, other transistors may have different pin
assignment).

[[File: bc547pins.png|100px]] [[File: bc547snapshot.jpg|200px]]

Electrolytic Capacitors are polarized. The negative lead is normally marked
by a white stripe having multiple minus signs on it ("- - - ").

This figure shows how to insert the components on the breadboard.

[[File: electrolytic.png|100px]] [[File: electrolyticsnapshot.jpg|200px]]

Install all the components and jumpers on the Breadboard as shown in this picture:

[[File: clockbreadboard.png|400px]]

When all the components and the jumpers have been put on the breadboard,
the circuit can be tested.
Plug the power supply to the + and - rails on both sides (you can add
jumpers to connect + and - of one side to the correspondent rails on the
other). The blue rail should be connected to the negative, the red one to
the positive.

[[File: jumpersbb.png|400px]]

Now plug a led diode to the master clock's output: push the longest
pin of the diode (its anode) in a hole of the output row and its shortest
pin (the cathode) to a hole of the minus rail.
Does it blink? I hope so. If it does your master clock is working, if it
not blinking double check the position of all the components and jumpers.

[[File: ledx.png|100px]] [[File: ledsnapshot.jpg|200px]]

=== How to build the 11 NAND gates ===

Schematics of the unit (already discussed in
[[No_more_secrets_in_your_CPU:_Part_1]]|Part1):

[[File: nandschem.png|400px]]

[[File: nandsnapshot.jpg|400px]]

For each gate you'll use:
* #2 transistors
* #2 10Kohm resistors
* #1 330ohm resistor
* #2 0.3" jumpers

Insert the components as depicted (row numbers refer to the first
NAND gate). Trim the pins of resistors before mounting them and
pay attention to install trasistors in the correct direction.

[[File: nandbb.png|600px]]

The same pattern should be repeated for all the other NAND gates.
The first row of each gate is 8,13,18,23,28,33,38,43,48,53,58.
For some gates the hole of the positive rail for the 330 ohm resistor
or the hole of the negative row for the jumper are not aligned.
Choose the closest available hole of the rail.

The following table maps each gate to the row numbers of its inputs and
output.

Gate In1 In2 Out
CLK -- -- 7
A 9 11 8
B 14 16 13
C 19 21 18
D 24 26 23
E 29 31 28
F 34 36 33
G 39 41 38
H 44 46 43
I 49 51 48
J 54 56 53
K 59 61 58

The circuit is complete. For the experiments we'll name the NAND gates
using the letters of the alphabeth, A to K.
The experiments will be carried out by adding jumpers to interconnect
the gates and the master clock in a specific topology.
All the inputs and outputs of the gates are connected to rows of the
right-hand side of the breadborad, so it is possible to set up the
experimental circuits by connecting the right rows on this side.

No other transistors, resistors, capacitors need to be further installed or
existing components moved in order to build one by one the components
of a CPU.

It is time to test the gates. Please test all of them because an error,
a misfunctioning component or a false contact may prevent complex circuits
from working properly.

For each gate: plug a led diode between the gate's output (the longest pin,
i.e. its anode) and a hole of a negative rail (here plug the shortest pin
of the led, its cathode).
The led should be on. Now use two jumpers to connect both inputs of the
gate to the positive rail. The led should turn off when both jumpers are
connected.
Now you can move the led and the jumpers to test the next gate.
Should all of them work properly? If yes, be brave of you.
You can move to the next stage and start experimenting on how these 11 NAND
gates can work as signal routers, do computations, memorize, count and much more.

=== How to build the keypad (optional) ===

It is convenient to have a keypad to provide input to the circuits.
Here is mine:

[[File:Keypad.jpg|300px]]

If you want to build one, take the second breadboard and connect one end of
each the button to the positive rail.

Then connect the positive rail of the keypad to the positive rail of the
main experimental breadboard.

The pin of each button which has not been connected to the positive rail
can be used to provide an input bit to a circuit.

For example you can take the pin of two buttons and connect them to a NAND
gate. When you push both buttons, a led installed on the NAND gate's output turns off.

=== A short note for real Electronic Engineers ===

I am a computer scientist, not an electronic engineer and this is an
educational tool.
I know that the design of real TTL and CMOS gates is quite different,
from an electronic, not logical, point of view.
The goal of this tool is to create a simple educational playground based on
cheap and off-the-shelf components.
BC547 are very common (at least in Europe (*)), while multiemitter transistors for
TTL or typeN and typeP MOSFET for CMOS are less common.

Each gate of the experimental board always drains about 13mA to work. The
current raises to 15mA when the output is zero. I am perfectly aware that
these are huge values for the current to drive each gate but in this way it
is possible to use a led diode as a logic probe.

(*) Many NPN transistors can be used instead of BC547. I have not tested it personally,
but I am confident that 2N2222 should work. 2N2222 is a very common NPN transistor in the US.

File:Lednotv2.png

2014-05-19T09:28:26Z

GiuliaN: GiuliaN ha caricato una nuova versione di "File:Lednotv2.png"

No more secrets in your CPU: Part 1

2014-05-19T09:25:09Z

GiuliaN:

This is the first of a set of postings.
I am writing here, on my BLiki, the draft of a booklet about Computer Architecture
in the spirit of "Making".

This booklet describes an educational tool created to reveal the secrets of
the basic elements of digital computers.

This is a picture of the "tool", just to whet your appetite.

[[File: nms1.jpg|400px]]

Nothing magic happens in the processor of your computers, it is just a
matter of circuits an commutation of electric currents.
Everything works using an elementary switching device: the transistor.

A transistor is an electronic component which is able to drive a high
current on the basis of a low control current. It is basically an
amplifier. The control pin is the base (B), the reference gate is the
emitter(E), the output gate is the collector(C).

[[File:transistor.png]]

The low control current flowing between the base and the emitter, enables
a high current between the collector and the emitter.
For NPN transistors, the ones we use, these currents are positive (the
potential, or voltage of the Base and Collector is higher than the
potential of the Emitter).
The symbol of a NPN transistor has the arrow of the emitter pointing
outwards. There are other transistors named PNP, having the inwards arrow
in their symbol. PNP transistors use negative currents instead of positive
currents.

For our purposes we will use our transistors as binary switches. In fact a
current of 0.5mA (almost) saturate a transistor of the type used in our
experiemental tool (BC547).
A transistor behaves like a remotely controlled finger pushing a button.
When a current flows through the transistor's base the finger pushes the
button, otherwise it keeps it released.

[[File:TransistorFingerv2.png]]

Let us consider this circuit:

[[File:Ledv2.png]]

The current flows through the resistor and the led diode which turns on.
The resistor in this circuit limits the current so that the diode cannot be
damaged.

Let us add a button to the previous circuit in this way:

[[File:Lednotv2.png]]

If you push the button, the current flows through the button where the
resistence is null instead of passing through the diode. As a consequence,
the led turns off.
If we use two buttons connected as depicted here below (in series), the led
diode turns off when both buttons get pushed.

[[File:nednand.png|800px]]

We have said that a transistor may work as a remotely controlled finger
which pushes a button, so we can redesign the circuits about using
transistors in lieu of buttons.

As we will see almost all the components of a CPU (a processor) can be
built using a large number of these circuits. More precisely the circuit
using two transistors is a basic brick that can can be used to build all the
others.

[[File:tnotnand.png|800px]]

The circuit on the left, having one input and one transistor, is a NOT
gate. It negates its input: when its input is connected to the positive pin
of the power supply (+ 5V) the output is 0V. If there is a led connected it
is off. Viceversa if the input is connected to the negative pin (0V), or
left not connected, the output is 5V, the led is on. We will call 0V as
the logical state 0 and the logical state 1 is +5V.

The logical table of a NOT gate is:
IN OUT
0 1
1 0

The second circuit is a Not AND, usually abbreviated as NAND.
Its logical table is:
IN1 IN2 OUT
0 0 1
0 1 1
1 0 1
1 1 0

In fact, in plain English the semantics of the conjunction "and" is that a
sentence consisting of two statements connected by an "and" is true if
both statements are true, it is false otherwise.
Our logic gate returns exactly the opposite result of an "and", if returns
1 when an "and" returns 0 and viceversa. It is a Not AND, the negation of
an AND.
Almost all (say all but one) circuits of a modern computer can be built
using NANDS.

For example, if the two inputs of a NAND gate are connected together the
circuit has the effect of a NOT. In this case, in fact, either both inputs
have value 1 or both value 0. Our "remotely controlled fingers" are tied
together so either both buttons are pushed or none. So, it is not necessary
to have a specific circuit for a NOT.

However, one relevant circuit cannot be built using NANDs: the master
clock.
A computer includes a lot of components able to perfom computations,
activate/deactivate functions. route data, store data etc. but all these
elements need a director.
Like an orchestra, a processor requires a component which provides all the
instruments/elements with a rhythm, a pace so that the result can be
either a synphony or a computation and not a chaos.
Every element has to perform its task in a synchronized manner.
Our director, however, has not a complex score to follow, it simply
generates a square wave, a coninuous sequence of 0 and 1 one following the
other always at the same pace or frequency.
When the advertisement of a computer says that it runs at one two or three
GHz (giga herts) it means that its director's stick goes up and down one,
two or three billion times per second.

This is the circuit of our master clock:

[[File:clock.png|600px]]

The circuit has been drawn to show the similitudes with our previous
circuits. If we forget for a moment the two capacitors, the circuit
configuration of the first transistor on the left (T1) is a NOT circuit.
It has its input forced to the value 1, then its output without the
capacitors would be 0.
Still watching the circuit without the capacitors, the other part
of the circuit would behave in a similar manner.
The base of the transistor in the middle (T2) is connected to 1 so a current
can flow through its emitter and then throw the base-emitter junction
of the transistor of the right (T3). As a consequence, both transistors
"close" their circuits, thus the output and the collector of the transistor
in the middle are at logical level zero.

The capacitors work as small batteries. When the output at the collector of T1
transistor is 0v, the capacitor at the base of T2 is charging.
Thic capacitor requires a lot of current to start charging and then
the current decreases as its tends to complete its charge. As a consequence
at the beginning of the charge process the potential at the base of
the transistor is close to zero and then it slowly
reaches 5 volts.
When the potential at the base of T2 is 0, T2 and T3 are open, but after
a while, when the current reaches a certain level, they switch.
When T2 and T3 close, the potential at the collector of T2 drops to zero
volts causing the other capacitor to start charging.
The current needed to charge this capacitor force the potential at the base
of T1 to 0v. T1 opens the circuit. The output at the collector of T1 goes
to one, i.e. 5v. The other capacitor is discharging.
After a while, when the capacitor on the left reaches a certain level of
charge T1 flips and closes its circuit. The output at its collector
returns to 0v and the cycle can be repeated from the beginning.

So, why we need T3?
The output at the collector of T2 would be very different from a square
wave. In fact, due to the current flowing through the capacitor the rising edge
of the wave would be very slow.
When T2 has just begun to switch, at the beginning of the rising edge, the
current is enough to force T3 to switch completely.
When our remotely controlled finger is still lightly touching T2, T2's
finger gives a strong push to T3.

This is a snapshot of my portable oscilloscope.

[[File: oscilloscope.jpg|500px]]

The top trace (blue) is taken at the collector of T2, the second trace
(yellow) is taken at the collector of T1 while the third (pink) is the
trace of a logical analyzer connected to the output (collector of T3).
As you can see the rising edge are quite smooth in the blue and pink
traces, not square waves at all.
These two traces show how T1 and T2 continue to swing between their two
states open/close.
T3 makes the rising edge steeper. It is not a perfect square wave,
but nothing is perfect in electronics.

The values of the components have been chosen to have a clock beating
at a frequency around 1Hz, i.e. 1 cycle per second.
It is much slower than the clocks of our personal computers, tablets or
portable phones, but the idea is the same.
The purpose of this educational tool is to show how all the basic
components of a CPU work. Phenomena changing at the rate of 1Hz or less
can be easily observated by humans.
Our master clock frequency in not exactly 1Hz and can slightly change
during the time. In fact, the values of the components are subject to
a tolerance and can vary due to the temperature.
Real master clocks use the electrical obscillations of a quartz crystal
to provide a square wave at a quite stable frequency.

File:Lednotv2.png

2014-05-19T09:24:40Z

GiuliaN:

No more secrets in your CPU: Part 1

2014-05-19T09:22:34Z

GiuliaN:

This is the first of a set of postings.
I am writing here, on my BLiki, the draft of a booklet about Computer Architecture
in the spirit of "Making".

This booklet describes an educational tool created to reveal the secrets of
the basic elements of digital computers.

This is a picture of the "tool", just to whet your appetite.

[[File: nms1.jpg|400px]]

Nothing magic happens in the processor of your computers, it is just a
matter of circuits an commutation of electric currents.
Everything works using an elementary switching device: the transistor.

A transistor is an electronic component which is able to drive a high
current on the basis of a low control current. It is basically an
amplifier. The control pin is the base (B), the reference gate is the
emitter(E), the output gate is the collector(C).

[[File:transistor.png]]

The low control current flowing between the base and the emitter, enables
a high current between the collector and the emitter.
For NPN transistors, the ones we use, these currents are positive (the
potential, or voltage of the Base and Collector is higher than the
potential of the Emitter).
The symbol of a NPN transistor has the arrow of the emitter pointing
outwards. There are other transistors named PNP, having the inwards arrow
in their symbol. PNP transistors use negative currents instead of positive
currents.

For our purposes we will use our transistors as binary switches. In fact a
current of 0.5mA (almost) saturate a transistor of the type used in our
experiemental tool (BC547).
A transistor behaves like a remotely controlled finger pushing a button.
When a current flows through the transistor's base the finger pushes the
button, otherwise it keeps it released.

[[File:TransistorFingerv2.png]]

Let us consider this circuit:

[[File:Ledv2.png]]

The current flows through the resistor and the led diode which turns on.
The resistor in this circuit limits the current so that the diode cannot be
damaged.

Let us add a button to the previous circuit in this way:

[[File:lednot.png]]

If you push the button, the current flows through the button where the
resistence is null instead of passing through the diode. As a consequence,
the led turns off.
If we use two buttons connected as depicted here below (in series), the led
diode turns off when both buttons get pushed.

[[File:nednand.png|800px]]

We have said that a transistor may work as a remotely controlled finger
which pushes a button, so we can redesign the circuits about using
transistors in lieu of buttons.

As we will see almost all the components of a CPU (a processor) can be
built using a large number of these circuits. More precisely the circuit
using two transistors is a basic brick that can can be used to build all the
others.

[[File:tnotnand.png|800px]]

The circuit on the left, having one input and one transistor, is a NOT
gate. It negates its input: when its input is connected to the positive pin
of the power supply (+ 5V) the output is 0V. If there is a led connected it
is off. Viceversa if the input is connected to the negative pin (0V), or
left not connected, the output is 5V, the led is on. We will call 0V as
the logical state 0 and the logical state 1 is +5V.

The logical table of a NOT gate is:
IN OUT
0 1
1 0

The second circuit is a Not AND, usually abbreviated as NAND.
Its logical table is:
IN1 IN2 OUT
0 0 1
0 1 1
1 0 1
1 1 0

In fact, in plain English the semantics of the conjunction "and" is that a
sentence consisting of two statements connected by an "and" is true if
both statements are true, it is false otherwise.
Our logic gate returns exactly the opposite result of an "and", if returns
1 when an "and" returns 0 and viceversa. It is a Not AND, the negation of
an AND.
Almost all (say all but one) circuits of a modern computer can be built
using NANDS.

For example, if the two inputs of a NAND gate are connected together the
circuit has the effect of a NOT. In this case, in fact, either both inputs
have value 1 or both value 0. Our "remotely controlled fingers" are tied
together so either both buttons are pushed or none. So, it is not necessary
to have a specific circuit for a NOT.

However, one relevant circuit cannot be built using NANDs: the master
clock.
A computer includes a lot of components able to perfom computations,
activate/deactivate functions. route data, store data etc. but all these
elements need a director.
Like an orchestra, a processor requires a component which provides all the
instruments/elements with a rhythm, a pace so that the result can be
either a synphony or a computation and not a chaos.
Every element has to perform its task in a synchronized manner.
Our director, however, has not a complex score to follow, it simply
generates a square wave, a coninuous sequence of 0 and 1 one following the
other always at the same pace or frequency.
When the advertisement of a computer says that it runs at one two or three
GHz (giga herts) it means that its director's stick goes up and down one,
two or three billion times per second.

This is the circuit of our master clock:

[[File:clock.png|600px]]

The circuit has been drawn to show the similitudes with our previous
circuits. If we forget for a moment the two capacitors, the circuit
configuration of the first transistor on the left (T1) is a NOT circuit.
It has its input forced to the value 1, then its output without the
capacitors would be 0.
Still watching the circuit without the capacitors, the other part
of the circuit would behave in a similar manner.
The base of the transistor in the middle (T2) is connected to 1 so a current
can flow through its emitter and then throw the base-emitter junction
of the transistor of the right (T3). As a consequence, both transistors
"close" their circuits, thus the output and the collector of the transistor
in the middle are at logical level zero.

The capacitors work as small batteries. When the output at the collector of T1
transistor is 0v, the capacitor at the base of T2 is charging.
Thic capacitor requires a lot of current to start charging and then
the current decreases as its tends to complete its charge. As a consequence
at the beginning of the charge process the potential at the base of
the transistor is close to zero and then it slowly
reaches 5 volts.
When the potential at the base of T2 is 0, T2 and T3 are open, but after
a while, when the current reaches a certain level, they switch.
When T2 and T3 close, the potential at the collector of T2 drops to zero
volts causing the other capacitor to start charging.
The current needed to charge this capacitor force the potential at the base
of T1 to 0v. T1 opens the circuit. The output at the collector of T1 goes
to one, i.e. 5v. The other capacitor is discharging.
After a while, when the capacitor on the left reaches a certain level of
charge T1 flips and closes its circuit. The output at its collector
returns to 0v and the cycle can be repeated from the beginning.

So, why we need T3?
The output at the collector of T2 would be very different from a square
wave. In fact, due to the current flowing through the capacitor the rising edge
of the wave would be very slow.
When T2 has just begun to switch, at the beginning of the rising edge, the
current is enough to force T3 to switch completely.
When our remotely controlled finger is still lightly touching T2, T2's
finger gives a strong push to T3.

This is a snapshot of my portable oscilloscope.

[[File: oscilloscope.jpg|500px]]

The top trace (blue) is taken at the collector of T2, the second trace
(yellow) is taken at the collector of T1 while the third (pink) is the
trace of a logical analyzer connected to the output (collector of T3).
As you can see the rising edge are quite smooth in the blue and pink
traces, not square waves at all.
These two traces show how T1 and T2 continue to swing between their two
states open/close.
T3 makes the rising edge steeper. It is not a perfect square wave,
but nothing is perfect in electronics.

The values of the components have been chosen to have a clock beating
at a frequency around 1Hz, i.e. 1 cycle per second.
It is much slower than the clocks of our personal computers, tablets or
portable phones, but the idea is the same.
The purpose of this educational tool is to show how all the basic
components of a CPU work. Phenomena changing at the rate of 1Hz or less
can be easily observated by humans.
Our master clock frequency in not exactly 1Hz and can slightly change
during the time. In fact, the values of the components are subject to
a tolerance and can vary due to the temperature.
Real master clocks use the electrical obscillations of a quartz crystal
to provide a square wave at a quite stable frequency.

File:Ledv2.png

2014-05-19T09:21:54Z

GiuliaN:

No more secrets in your CPU: Part 1

2014-05-19T09:19:48Z

GiuliaN:

This is the first of a set of postings.
I am writing here, on my BLiki, the draft of a booklet about Computer Architecture
in the spirit of "Making".

This booklet describes an educational tool created to reveal the secrets of
the basic elements of digital computers.

This is a picture of the "tool", just to whet your appetite.

[[File: nms1.jpg|400px]]

Nothing magic happens in the processor of your computers, it is just a
matter of circuits an commutation of electric currents.
Everything works using an elementary switching device: the transistor.

A transistor is an electronic component which is able to drive a high
current on the basis of a low control current. It is basically an
amplifier. The control pin is the base (B), the reference gate is the
emitter(E), the output gate is the collector(C).

[[File:transistor.png]]

The low control current flowing between the base and the emitter, enables
a high current between the collector and the emitter.
For NPN transistors, the ones we use, these currents are positive (the
potential, or voltage of the Base and Collector is higher than the
potential of the Emitter).
The symbol of a NPN transistor has the arrow of the emitter pointing
outwards. There are other transistors named PNP, having the inwards arrow
in their symbol. PNP transistors use negative currents instead of positive
currents.

For our purposes we will use our transistors as binary switches. In fact a
current of 0.5mA (almost) saturate a transistor of the type used in our
experiemental tool (BC547).
A transistor behaves like a remotely controlled finger pushing a button.
When a current flows through the transistor's base the finger pushes the
button, otherwise it keeps it released.

[[File:TransistorFingerv2.png]]

Let us consider this circuit:

[[File:led.png]]

The current flows through the resistor and the led diode which turns on.
The resistor in this circuit limits the current so that the diode cannot be
damaged.

Let us add a button to the previous circuit in this way:

[[File:lednot.png]]

If you push the button, the current flows through the button where the
resistence is null instead of passing through the diode. As a consequence,
the led turns off.
If we use two buttons connected as depicted here below (in series), the led
diode turns off when both buttons get pushed.

[[File:nednand.png|800px]]

We have said that a transistor may work as a remotely controlled finger
which pushes a button, so we can redesign the circuits about using
transistors in lieu of buttons.

As we will see almost all the components of a CPU (a processor) can be
built using a large number of these circuits. More precisely the circuit
using two transistors is a basic brick that can can be used to build all the
others.

[[File:tnotnand.png|800px]]

The circuit on the left, having one input and one transistor, is a NOT
gate. It negates its input: when its input is connected to the positive pin
of the power supply (+ 5V) the output is 0V. If there is a led connected it
is off. Viceversa if the input is connected to the negative pin (0V), or
left not connected, the output is 5V, the led is on. We will call 0V as
the logical state 0 and the logical state 1 is +5V.

The logical table of a NOT gate is:
IN OUT
0 1
1 0

The second circuit is a Not AND, usually abbreviated as NAND.
Its logical table is:
IN1 IN2 OUT
0 0 1
0 1 1
1 0 1
1 1 0

In fact, in plain English the semantics of the conjunction "and" is that a
sentence consisting of two statements connected by an "and" is true if
both statements are true, it is false otherwise.
Our logic gate returns exactly the opposite result of an "and", if returns
1 when an "and" returns 0 and viceversa. It is a Not AND, the negation of
an AND.
Almost all (say all but one) circuits of a modern computer can be built
using NANDS.

For example, if the two inputs of a NAND gate are connected together the
circuit has the effect of a NOT. In this case, in fact, either both inputs
have value 1 or both value 0. Our "remotely controlled fingers" are tied
together so either both buttons are pushed or none. So, it is not necessary
to have a specific circuit for a NOT.

However, one relevant circuit cannot be built using NANDs: the master
clock.
A computer includes a lot of components able to perfom computations,
activate/deactivate functions. route data, store data etc. but all these
elements need a director.
Like an orchestra, a processor requires a component which provides all the
instruments/elements with a rhythm, a pace so that the result can be
either a synphony or a computation and not a chaos.
Every element has to perform its task in a synchronized manner.
Our director, however, has not a complex score to follow, it simply
generates a square wave, a coninuous sequence of 0 and 1 one following the
other always at the same pace or frequency.
When the advertisement of a computer says that it runs at one two or three
GHz (giga herts) it means that its director's stick goes up and down one,
two or three billion times per second.

This is the circuit of our master clock:

[[File:clock.png|600px]]

The circuit has been drawn to show the similitudes with our previous
circuits. If we forget for a moment the two capacitors, the circuit
configuration of the first transistor on the left (T1) is a NOT circuit.
It has its input forced to the value 1, then its output without the
capacitors would be 0.
Still watching the circuit without the capacitors, the other part
of the circuit would behave in a similar manner.
The base of the transistor in the middle (T2) is connected to 1 so a current
can flow through its emitter and then throw the base-emitter junction
of the transistor of the right (T3). As a consequence, both transistors
"close" their circuits, thus the output and the collector of the transistor
in the middle are at logical level zero.

The capacitors work as small batteries. When the output at the collector of T1
transistor is 0v, the capacitor at the base of T2 is charging.
Thic capacitor requires a lot of current to start charging and then
the current decreases as its tends to complete its charge. As a consequence
at the beginning of the charge process the potential at the base of
the transistor is close to zero and then it slowly
reaches 5 volts.
When the potential at the base of T2 is 0, T2 and T3 are open, but after
a while, when the current reaches a certain level, they switch.
When T2 and T3 close, the potential at the collector of T2 drops to zero
volts causing the other capacitor to start charging.
The current needed to charge this capacitor force the potential at the base
of T1 to 0v. T1 opens the circuit. The output at the collector of T1 goes
to one, i.e. 5v. The other capacitor is discharging.
After a while, when the capacitor on the left reaches a certain level of
charge T1 flips and closes its circuit. The output at its collector
returns to 0v and the cycle can be repeated from the beginning.

So, why we need T3?
The output at the collector of T2 would be very different from a square
wave. In fact, due to the current flowing through the capacitor the rising edge
of the wave would be very slow.
When T2 has just begun to switch, at the beginning of the rising edge, the
current is enough to force T3 to switch completely.
When our remotely controlled finger is still lightly touching T2, T2's
finger gives a strong push to T3.

This is a snapshot of my portable oscilloscope.

[[File: oscilloscope.jpg|500px]]

The top trace (blue) is taken at the collector of T2, the second trace
(yellow) is taken at the collector of T1 while the third (pink) is the
trace of a logical analyzer connected to the output (collector of T3).
As you can see the rising edge are quite smooth in the blue and pink
traces, not square waves at all.
These two traces show how T1 and T2 continue to swing between their two
states open/close.
T3 makes the rising edge steeper. It is not a perfect square wave,
but nothing is perfect in electronics.

The values of the components have been chosen to have a clock beating
at a frequency around 1Hz, i.e. 1 cycle per second.
It is much slower than the clocks of our personal computers, tablets or
portable phones, but the idea is the same.
The purpose of this educational tool is to show how all the basic
components of a CPU work. Phenomena changing at the rate of 1Hz or less
can be easily observated by humans.
Our master clock frequency in not exactly 1Hz and can slightly change
during the time. In fact, the values of the components are subject to
a tolerance and can vary due to the temperature.
Real master clocks use the electrical obscillations of a quartz crystal
to provide a square wave at a quite stable frequency.

File:TransistorFingerv2.png

2014-05-19T09:18:36Z

GiuliaN:

No more secrets in your CPU: Part 1

2014-05-16T13:39:13Z

GiuliaN:

This is the first of a set of postings.
I am writing here, on my BLiki, the draft of a booklet about Computer Architecture
in the spirit of "Making".

This booklet describes an educational tool created to reveal the secrets of
the basic elements of digital computers.

This is a picture of the "tool", just to whet your appetite.

[[File: nms1.jpg|400px]]

Nothing magic happens in the processor of your computers, it is just a
matter of circuits an commutation of electric currents.
Everything works using an elementary switching device: the transistor.

A transistor is an electronic component which is able to drive a high
current on the basis of a low control current. It is basically an
amplifier. The control pin is the base (B), the reference gate is the
emitter(E), the output gate is the collector(C).

[[File:transistor.png]]

The low control current flowing between the base and the emitter, enables
a high current between the collector and the emitter.
For NPN transistors, the ones we use, these currents are positive (the
potential, or voltage of the Base and Collector is higher than the
potential of the Emitter).
The symbol of a NPN transistor has the arrow of the emitter pointing
outwards. There are other transistors named PNP, having the inwards arrow
in their symbol. PNP transistors use negative currents instead of positive
currents.

For our purposes we will use our transistors as binary switches. In fact a
current of 0.5mA (almost) saturate a transistor of the type used in our
experiemental tool (BC547).
A transistor behaves like a remotely controlled finger pushing a button.
When a current flows through the transistor's base the finger pushes the
button, otherwise it keeps it released.

[[File:transistorfinger.png]]

Let us consider this circuit:

[[File:led.png]]

The current flows through the resistor and the led diode which turns on.
The resistor in this circuit limits the current so that the diode cannot be
damaged.

Let us add a button to the previous circuit in this way:

[[File:lednot.png]]

If you push the button, the current flows through the button where the
resistence is null instead of passing through the diode. As a consequence,
the led turns off.
If we use two buttons connected as depicted here below (in series), the led
diode turns off when both buttons get pushed.

[[File:nednand.png|800px]]

We have said that a transistor may work as a remotely controlled finger
which pushes a button, so we can redesign the circuits about using
transistors in lieu of buttons.

As we will see almost all the components of a CPU (a processor) can be
built using a large number of these circuits. More precisely the circuit
using two transistors is a basic brick that can can be used to build all the
others.

[[File:tnotnand.png|800px]]

The circuit on the left, having one input and one transistor, is a NOT
gate. It negates its input: when its input is connected to the positive pin
of the power supply (+ 5V) the output is 0V. If there is a led connected it
is off. Viceversa if the input is connected to the negative pin (0V), or
left not connected, the output is 5V, the led is on. We will call 0V as
the logical state 0 and the logical state 1 is +5V.

The logical table of a NOT gate is:
IN OUT
0 1
1 0

The second circuit is a Not AND, usually abbreviated as NAND.
Its logical table is:
IN1 IN2 OUT
0 0 1
0 1 1
1 0 1
1 1 0

In fact, in plain English the semantics of the conjunction "and" is that a
sentence consisting of two statements connected by an "and" is true if
both statements are true, it is false otherwise.
Our logic gate returns exactly the opposite result of an "and", if returns
1 when an "and" returns 0 and viceversa. It is a Not AND, the negation of
an AND.
Almost all (say all but one) circuits of a modern computer can be built
using NANDS.

For example, if the two inputs of a NAND gate are connected together the
circuit has the effect of a NOT. In this case, in fact, either both inputs
have value 1 or both value 0. Our "remotely controlled fingers" are tied
together so either both buttons are pushed or none. So, it is not necessary
to have a specific circuit for a NOT.

However, one relevant circuit cannot be built using NANDs: the master
clock.
A computer includes a lot of components able to perfom computations,
activate/deactivate functions. route data, store data etc. but all these
elements need a director.
Like an orchestra, a processor requires a component which provides all the
instruments/elements with a rhythm, a pace so that the result can be
either a synphony or a computation and not a chaos.
Every element has to perform its task in a synchronized manner.
Our director, however, has not a complex score to follow, it simply
generates a square wave, a coninuous sequence of 0 and 1 one following the
other always at the same pace or frequency.
When the advertisement of a computer says that it runs at one two or three
GHz (giga herts) it means that its director's stick goes up and down one,
two or three billion times per second.

This is the circuit of our master clock:

[[File:clock.png|600px]]

The circuit has been drawn to show the similitudes with our previous
circuits. If we forget for a moment the two capacitors, the circuit
configuration of the first transistor on the left (T1) is a NOT circuit.
It has its input forced to the value 1, then its output without the
capacitors would be 0.
Still watching the circuit without the capacitors, the other part
of the circuit would behave in a similar manner.
The base of the transistor in the middle (T2) is connected to 1 so a current
can flow through its emitter and then throw the base-emitter junction
of the transistor of the right (T3). As a consequence, both transistors
"close" their circuits, thus the output and the collector of the transistor
in the middle are at logical level zero.

The capacitors work as small batteries. When the output at the collector of T1
transistor is 0v, the capacitor at the base of T2 is charging.
Thic capacitor requires a lot of current to start charging and then
the current decreases as its tends to complete its charge. As a consequence
at the beginning of the charge process the potential at the base of
the transistor is close to zero and then it slowly
reaches 5 volts.
When the potential at the base of T2 is 0, T2 and T3 are open, but after
a while, when the current reaches a certain level, they switch.
When T2 and T3 close, the potential at the collector of T2 drops to zero
volts causing the other capacitor to start charging.
The current needed to charge this capacitor force the potential at the base
of T1 to 0v. T1 opens the circuit. The output at the collector of T1 goes
to one, i.e. 5v. The other capacitor is discharging.
After a while, when the capacitor on the left reaches a certain level of
charge T1 flips and closes its circuit. The output at its collector
returns to 0v and the cycle can be repeated from the beginning.

So, why we need T3?
The output at the collector of T2 would be very different from a square
wave. In fact, due to the current flowing through the capacitor the rising edge
of the wave would be very slow.
When T2 has just begun to switch, at the beginning of the rising edge, the
current is enough to force T3 to switch completely.
When our remotely controlled finger is still lightly touching T2, T2's
finger gives a strong push to T3.

This is a snapshot of my portable oscilloscope.

[[File: oscilloscope.jpg|500px]]

The top trace (blue) is taken at the collector of T2, the second trace
(yellow) is taken at the collector of T1 while the third (pink) is the
trace of a logical analyzer connected to the output (collector of T3).
As you can see the rising edge are quite smooth in the blue and pink
traces, not square waves at all.
These two traces show how T1 and T2 continue to swing between their two
states open/close.
T3 makes the rising edge steeper. It is not a perfect square wave,
but nothing is perfect in electronics.

The values of the components have been chosen to have a clock beating
at a frequency around 1Hz, i.e. 1 cycle per second.
It is much slower than the clocks of our personal computers, tablets or
portable phones, but the idea is the same.
The purpose of this educational tool is to show how all the basic
components of a CPU work. Phenomena changing at the rate of 1Hz or less
can be easily observated by humans.
Our master clock frequency in not exactly 1Hz and can slightly change
during the time. In fact, the values of the components are subject to
a tolerance and can vary due to the temperature.
Real master clocks use the electrical obscillations of a quartz crystal
to provide a square wave at a quite stable frequency.

No more secrets in your CPU: Part 1

2014-05-16T13:25:21Z

GiuliaN:

This is the first of a set of postings.
I am writing here, on my BLiki, the draft of a booklet about Computer Architecture
in the spirit of "Making".

This booklet describes an educational tool created to reveal the secrets of
the basic elements of digital computers.

This is a picture of the "tool", just to whet your appetite.

[[File: nms1.jpg|400px]]

Nothing magic happens in the processor of your computers, it is just a
matter of circuits an commutation of electric currents.
Everything works using an elementary switching device: the transistor.

A transistor is an electronic component which is able to drive a high
current on the basis of a low control current. It is basically an
amplifier. The control pin is the base (B), the reference gate is the
emitter(E), the output gate is the collector(C).

[[File:transistor.png]]

The low control current flowing between the base and the emitter, enables
a high current between the collector and the emitter.
For NPN transistors, the ones we use, these currents are positive (the
potential, or voltage of the Base and Collector is higher than the
potential of the Emitter).
The symbol of a NPN transistor has the arrow of the emitter pointing
outwards. There are other transistors named PNP, having the inwards arrow
in their symbol. PNP transistors use negative currents instead of positive
currents.

For our purposes we will use our transistors as binary switches. In fact a
current of 0.5mA (almost) saturate a transistor of the type used in our
experiemental tool (BC547).
A transistor behaves like a remotely controlled finger pushing a button.
When a current flows through the transistor's base the finger pushes the
button, otherwise it keeps it released.

[[File:transistorfinger.png]]

Let us consider this circuit:

[[File:led.png]]

The current flows through the resistor and the led diode which turns on.
The resistor in this circuit limits the current so that the diode cannot be
damaged.

Let us add a button to the previous circuit in this way:

[[File:lednot.png]]

If you push the button, the current flows through the button where the
resistence is null instead of passing through the diode. As a consequence,
the led turns off.
If we use two buttons connected as depicted here below (in series), the led
diode turns off when both buttons get pushed.

[[File:nednand.png|800px]]

We have said that a transistor may work as a remotely controlled finger
which pushes a button, so we can redesign the circuits about using
transistors in lieu of buttons.

As we will see almost all the components of a CPU (a processor) can be
built using a large number of these circuits. More precisely the circuit
using two transistors is a basic brick that can can be used to build all the
others.

[[File:tnotnand.png|800px]]

The circuit on the left, having one input and one transistor, is a NOT
gate. It negates its input: when its input is connected to the positive pin
of the power supply (+ 5V) the output is 0V. If there is a led connected it
is off. Viceversa if the input is connected to the negative pin (0V), or
left not connected, the output is 5V, the led is on. We will call 0V as
the logical state 0 and the logical state 1 is +5V.

The logical table of a NOT gate is:
IN OUT
0 1
1 0

The second circuit is a Not AND, usually abbreviated as NAND.
Its logical table is:
IN1 IN2 OUT
0 0 1
0 1 1
1 0 1
1 1 0

In fact, in plain English the semantics of the conjunction "and" is that a
sentence consisting of two statements connected by an "and" is true if
both statements are true, it is false otherwise.
Our logic gate returns exactly the opposite result of an "and", if returns
1 when an "and" returns 0 and viceversa. It is a Not AND, the negation of
an AND.
Almost all (say all but one) circuits of a modern computer can be built
using NANDS.

For example, if the two inputs of a NAND gate are connected together the
circuit has the effect of a NOT. In this case, in fact, either both inputs
have value 1 or both value 0. Our "remotely controlled fingers" are tied
together so either both buttons are pushed or none. So, it is not necessary
to have a specific circuit for a NOT.

However, one relevant circuit cannot be built using NANDs: the master
clock.
A computer includes a lot of components able to perfom computations,
activate/deactivate functions. route data, store data etc. but all these
elements need a director.
Like an orchestra, a processor requires a component which provides all the
instruments/elements with a rhythm, a pace so that the result can be
either a synphony or a computation and not a chaos.
Every element has to perform its task in a synchronized manner.
Our director, however, has not a complex score to follow, it simply
generates a square wave, a coninuous sequence of 0 and 1 one following the
other always at the same pace or frequency.
When the advertisement of a computer says that it runs at one two or three
GHz (giga herts) it means that its director's stick goes up and down one,
two or three billion times per second.

This is the circuit of our master clock:

[[File:clock.png|600px]]

The circuit has been drawn to show the similitudes with our previous
circuits. If we forget for a moment the two capacitors, the circuit
configuration of the first transistor on the left (T1) is a NOT circuit.
It has its input forced to the value 1, then its output without the
capacitors would be 0.
Still watching the circuit without the capacitors, the other part
of the circuit would behave in a similar manner.
The base of the transistor in the middle (T2) is connected to 1 so a current
can flow through its emitter and then throw the base-emitter junction
of the transistor of the right (T3). As a consequence, both transistors
"close" their circuits, thus the output and the collector of the transistor
in the middle are at logical level zero.

The capacitors work as small batteries. When the output at the collector of T1
transistor is 0v, the capacitor at the base of T2 is charging.
Thic capacitor requires a lot of current to start charging and then
the current decreases as its tends to complete its charge. As a consequence
at the beginning of the charge process the potential at the base of
the transistor is close to zero and then it slowly
reaches 5 volts.
When the potential at the base of T2 is 0, T2 and T3 are open, but after
a while, when the current reaches a certain level, they switch.
When T2 and T3 close, the potential at the collector of T2 drops to zero
volts causing the other capacitor to start charging.
The current needed to charge this capacitor force the potential at the base
of T1 to 0v. T1 opens the circuit. The output at the collector of T1 goes
to one, i.e. 5v. The other capacitor is discharging.
After a while, when the capacitor on the left reaches a certain level of
charge T1 flips and closes its circuit. The output at its collector
returns to 0v and the cycle can be repeated from the beginning.

So, why we need T3?
The output at the collector of T2 would be very different from a square
wave. In fact, due to the current flowing through the capacitor the rising edge
of the wave would be very slow.
When T2 has just begun to switch, at the beginning of the rising edge, the
current is enough to force T3 to switch completely.
When our remotely controlled finger is still lightly touching T2, T2's
finger gives a strong push to T3.

This is a snapshot of my portable oscilloscope.

[[File: oscilloscope.jpg|500px]]

The top trace (blue) is taken at the collector of T2, the second trace
(yellow) is taken at the collector of T1 while the third (pink) is the
trace of a logical analyzer connected to the output (collector of T3).
As you can see the rising edge are quite smooth in the blue and pink
traces, not square waves at all.
These two traces show how T1 and T2 continue to swing between their two
states open/close.
T3 makes the rising edge steeper. It is not a perfect square wave,
but nothing is perfect in electronics.

The values of the components have been chosen to have a clock beating
at a frequency around 1Hz, i.e. 1 cycle per second.
It is muc slower than the clocks of out perconal computers, tablets or
portable phones, but the idea is the same.
The purpose of this educational tool is to show how all the basic
components of a CPU work. Phenomena changing at the rate of 1Hz or less
can be easily observated by humans.
Our master clock frequency in not exactly 1Hz and can slightly change
during the time. In fact, the values of the components are subject to
a tolerance and can vary due to the temperature.
Real master clocks use the electrical obscillations of a quartz crystal
to provide a square wave at a quite stable frequency.

No more secrets in your CPU: Part 1

2014-05-16T11:49:24Z

GiuliaN:

This is the first of a set of postings.
I am writing here, on my BLiki, the draft of a booklet about Computer Architecture
in the spirit of "Making".

This booklet describes an educational tool created to reveal the secrets of
the basic elements of digital computers.

This is a picture of the "tool", just to whet your appetite.

[[File: nms1.jpg|400px]]

Nothing magic happens in the processor of your computers, it is just a
matter of circuits an commutation of electric currents.
Everything works using an elementary switching device: the transistor.

A transistor is an electronic component which is able to drive a high
current on the basis of a low control current. It is basically an
amplifier. The control pin is the base (B), the reference gate is the
emitter(E), the output gate is the collector(C).

[[File:transistor.png]]

The low control current flowing between the base and the emitter, enables
a high current between the collector and the emitter.
For NPN transistors, the ones we use, these currents are positive (the
potential, or voltage of the Base and Collector is higher than the
potential of the Emitter).
The symbol of a NPN transistor has the arrow of the emitter pointing
outwards. There are other transistors named PNP, having the inwards arrow
in their symbol. PNP transistors use negative currents instead of positive
currents.

For our purposes we will use our transistors as binary switches. In fact a
current of 0.5mA (almost) saturate a transistor of the type used in our
experiemental tool (BC547).
A transistor behaves like a remotely controlled finger pushing a button.
When a current flows through the transistor's base the finger pushes the
button, otherwise it keeps it released.

[[File:transistorfinger.png]]

Let us consider this circuit:

[[File:led.png]]

The current flows through the resistor and the led diode which turns on.
The resistor in this circuit limits the current so that the diode cannot be
damaged.

Let us add a button to the previous circuit in this way:

[[File:lednot.png]]

If you push the button, the current flows through the button where the
resistence is null instead of passing through the diode. As a consequence,
the led turns off.
If we use two buttons connected as depicted here below (in series), the led
diode turns off when both buttons get pushed.

[[File:nednand.png|800px]]

We have said that a transistor may work as a remotely controlled finger
which pushes a button, so we can redesign the circuits about using
transistors in lieu of buttons.

As we will see almost all the components of a CPU (a processor) can be
built using a large number of these circuits. More precisely the circuit
using two transistors is a basic brick that can can be used to build all the
others.

[[File:tnotnand.png|800px]]

The circuit on the left, having one input and one transistor, is a NOT
gate. It negates its input: when its input is connected to the positive pin
of the power supply (+ 5V) the output is 0V. If there is a led connected it
is off. Viceversa if the input is connected to the negative pin (0V), or
left not connected, the output is 5V, the led is on. We will call 0V as
the logical state 0 and the logical state 1 is +5V.

The logical table of a NOT gate is:
IN OUT
0 1
1 0

The second circuit is a Not AND, usually abbreviated as NAND.
Its logical table is:
IN1 IN2 OUT
0 0 1
0 1 1
1 0 1
1 1 0

In fact, in plain English the semantics of the conjunction "and" is that a
sentence consisting of two statements connected by an "and" is true if
both statements are true, it is false otherwise.
Our logic gate returns exactly the opposite result of an "and", if returns
1 when an "and" returns 0 and viceversa. It is a Not AND, the negation of
an AND.
Almost all (say all but one) circuits of a modern computer can be built
using NANDS.

For example, if the two inputs of a NAND gate are connected together the
circuit has the effect of a NOT. In this case, in fact, either both inputs
have value 1 or both value 0. Our "remotely controlled fingers" are tied
together so either both buttons are pushed or none. So, it is not necessary
to have a specific circuit for a NOT.

However, one relevant circuit cannot be built using NANDs: the master
clock.
A computer includes a lot of components able to perfom computations,
activate/deactivate functions. route data, store data etc. but all these
elements need a director.
Like an orchestra, a processor requires a component which provides all the
instruments/elements with a rhythm, a pace so that the result can be
either a synphony or a computation and not a chaos.
Every element has to perform its task in a synchronized manner.
Our director, however, has not a complex score to follow, it simply
generates a square wave, a coninuous sequence of 0 and 1 one following the
other qlways at the same pace or frequency.
When the advertisement of a computer says that it runs at one two or three
GHz (giga herts) it means that its director's stick goes up and down one,
two or three billion times per second.

This is the circuit of our master clock:

[[File:clock.png|600px]]

The circuit has been drawn to show the similitudes with our previous
circuits. If we forget for a moment the two capacitors, the circuit
configuration of the first transistor on the left (T1) is a NOT circuit.
It has its input forced to the value 1, then its output without the
capacitors would be 0.
Still watching the circuit without the capacitors, the other part
of the circuit would behave in a similar manner.
The base of the transistor in the middle (T2) is connected to 1 so a current
can flow through its emitter and then throw the base-emitter junction
of the transistor of the right (T3). As a consequence, both transistors
"close" their circuits, thus the output and the collector of the transistor
in the middle are at logical level zero.

The capacitors work as small batteries. When the output at the collector of T1
transistor is 0v, the capacitor at the base of T2 is charging.
Thic capacitor requires a lot of current to start charging and then
the current decreases as its tends to complete its charge. As a consequence
at the beginning of the charge process the potential at the base of
the transistor is close to zero and then it slowly
reaches 5 volts.
When the potential at the base of T2 is 0, T2 and T3 are open, but after
a while, when the current reaches a certain level, they switch.
When T2 and T3 close, the potential at the collector of T2 drops to zero
volts causing the other capacitor to start charging.
The current needed to charge this capacitor force the potential at the base
of T1 to 0v. T1 opens the circuit. The output at the collector of T1 goes
to one, i.e. 5v. The other capacitor is discharging.
After a while, when the capacitor on the left reaches a certain level of
charge T1 flips and closes its circuit. The output at its collector
returns to 0v and the cycle can be repeated from the beginning.

So, why we need T3?
The output at the collector of T2 would be very different from a square
wave. In fact, due to the current flowing through the capacitor the rising edge
of the wave would be very slow.
When T2 has just begun to switch, at the beginning of the rising edge, the
current is enough to force T3 to switch completely.
When our remotely controlled finger is still lightly touching T2, T2's
finger gives a strong push to T3.

This is a snapshot of my portable oscilloscope.

[[File: oscilloscope.jpg|500px]]

The top trace (blue) is taken at the collector of T2, the second trace
(yellow) is taken at the collector of T1 while the third (pink) is the
trace of a logical analyzer connected to the output (collector of T3).
As you can see the rising edge are quite smooth in the blue and pink
traces, not square waves at all.
These two traces show how T1 and T2 continue to swing between their two
states open/close.
T3 makes the rising edge steeper. It is not a perfect square wave,
but nothing is perfect in electronics.

The values of the components have been chosen to have a clock beating
at a frequency around 1Hz, i.e. 1 cycle per second.
It is muc slower than the clocks of out perconal computers, tablets or
portable phones, but the idea is the same.
The purpose of this educational tool is to show how all the basic
components of a CPU work. Phenomena changing at the rate of 1Hz or less
can be easily observated by humans.
Our master clock frequency in not exactly 1Hz and can slightly change
during the time. In fact, the values of the components are subject to
a tolerance and can vary due to the temperature.
Real master clocks use the electrical obscillations of a quartz crystal
to provide a square wave at a quite stable frequency.