And we started by building a counter that counts through each step of our

Instruction cycle at each instruction that we that we want to define for a computer whether it's load a [add]

Output each of those instructions is made up of you know up to five or really oh

It's always five old sometimes the last steps don't do anything

But they all five different micro instructions and this counter counts through from zero to four to keep track of which step

We're on and what we saw is that?

[for] T0 and T1 those first two steps of the micro instruction those are always the same regardless of which instruction

We're actually trying to execute because those two steps are the steps that fetched the instruction from memory

And put it into the instruction register and so in fact

We're able to sort of temporarily wire those up just by you know manually connecting you know these these signals for T0 and t1

through through an inverter to the appropriate

logic signals here on the control

[electrical] word, but what I want to do in this video is replace this kind of temporary

You know demonstration here for those first two steps with logic that's going to be able to carry out all of the steps for any

instruction that we might want the computer to be able to do and so in order to sort of

Understand how that's going to work. There's really kind of [two] pieces of information that feed into what?

Control signals need to be active at any point in time

and one of those pieces of information is which step we're on here so which of which of these time steps were on so

And that's what we're doing now. We're on t 0 or t 1 we have signals that indicate that

But that's one piece of information, and so you know we're where we are in this count is one piece of information

but then the other piece of information once we get into t 2 t 3 and t 4

It's going to be different based on which instruction

we're actually executing and so that piece of information is here in the instruction register because by the time we get to [t] 2

These first two steps will have loaded the appropriate instruction

So if the instruction is load a you know that instruction is [zero] [zero] [zero] [one] will have a zero zero zero one

sitting in the instruction register, so we have that information here, so

All of the information we need in order to be able to set all of the control signals appropriately is

Available in a combination of what's in the instruction register?

plus

Where we are in our in our count, so where we are in the actual instruction cycle

So one way to look at what we've [got] so far

For time t 0 and t 1 we're saying for t 0 we're doing counter out in memory address register

In and that actually doesn't matter which instruction, we're executing because really at this point in the process we don't even know what instruction

We're executing we have to fetch it for memory first, so [teezer]

We're doing these things so [another] way to look at that is kind of with a truth table here where we say

We [have] the instruction which instruction is loaded which is 4 bits

And then we have the step which [is] 3 bits and that counts from 0 to 4 in binary?

because each instruction cycle is is 5 clock cycles long and

So another way to kind of look at this is to say well

Regardless of what instruction so we don't care what's in the instruction [register] for Step 0?

We want to do counter out and memory address register in

So in other words our control word over here is going to look like this. We're [going] [to] have [a] counter out

We're gonna have that is a 1 and?

then memory address register in is also going to be a 1 and then the rest of these are all going to be zeros and

[so] that's what our control word looks like

Whenever we're at time T0. Where its depth 0 regardless of what instructions. It's not the same thing

We're saying here so t0 doesn't matter what instruction. Those [2] bits are set

Now time T1. We have the 3 bits set so [ram] out

So we're taking the contents of ram instruction register in we're putting that content into the instruction register

and then we're also incrementing the program counter so counter enable and

so again at

Time T1 where it work step one here doesn't matter what instruction because this is the same for every instruction or execution

In this case we have ram out is

Set to 1 and then instruction register in is set to a1 so we're moving

contents from Ram into the instruction register

and then were also incrementing the counter so counter enabled is over here at the program Counter and

Then the rest of these are zeros a little carried away and added an extra 0 there last time [would]

I forgot. [I'd] left a little blank there

So this is essentially what we've got now

Right so step [0] we're doing this this thing and step [1] we're doing this other thing

So now where it gets interesting is at this point after we've gone through these first two steps the instruction register

Now actually has the the instruction in it and so for example. [if] our program here was load a 14

The instruction register the instruction for that is 0 0 0 1 that's that's the instruction for Load a which

You know we just made that up, [but] that's that's what we're saying load a is

and then the the number the last four bits here is the is the

You know operand for this or it's a memory address location on we're loading data from [in] [to] the a register

But what shows up in the first four bits, so the destruction register is there a 0 0 1?

so in that case we have

0 0 0 1 in our instruction register

for the next three steps so that's going to be step 0 1 0

0 1 [1] and then 1 0 0 and then once the this

Step counter here gets to gets to 4 it resets back to 0 which we saw in the last video

And so in this case since we [have] 0 0 0 1 in our instruction

Register we know that we're going to be doing a load a because that's that's load a and so

The the steps for Load a which we talked about in a previous video is

we want to take the contents of the instruction register out and

Memory address register in so we're essentially

You know if we're [doing] a load a 14, we're moving that 14 into the memory address register

So that we can fetch whatever is in that [particular] location of memory

And then in the next step we do ram out

We so we take the contents of memory and put it into the a register a register in so in other words

if our instruction register says 0 0 0 1 and, we're on step 3 excuse me step 2 0 1 0

Then we say instruction register out and memory address register in and then everything else is zeros

And then for Load a at time T3. We say ram out a register in

so ram out a

register in and the rest are zeros

And so that's everything for a load a command

We don't actually need to do anything at time t four so in this case

We'll [just] leave all of those signals low and that way for that clock cycle the computer won't do anything now

[the] next instruction is is add and add the

Opcode for that is zero zero one zero

and when that when that

instruction is zero zero one zero we do something different [4] times [t] [2] [t] [3] and [t] [4]

So these these in this case here

This was load a but for add the instruction is going to be [zero] [zero] [one] [zero] [and] it'll be zero zero one zero

for those last three steps of the instruction cycle, so this is the add command and

The way the add Command works is of course

We've already gone through for step zero and one we fetched the add command from from memory, and that's the same for every command

but then four

steps so 0 1 2 3 and 4

[for] steps 2 3 and 4 for the add command [so] the first thing we want to do is we want to take instruction register

out and

Memory address register in so we want to take the the the location, so if we're saying add 15

We want to we [want] to go to memory address location 15 and get whatever is in there and add it to the hey register

So add 15 so we take the instruction register out we put that address into the memory address register

and then we take the contents [of] ram so [ram] out and

put that into the b register, right so be in is over here and

Then that'll start to add. Whatever is in a and B

And so we take the sum out from that addition and put that back into to a register so a in

And so these are the steps for the add command, and I'll just fill in the rest of these zeros

So that's the sequence of control signals that we want for the add command and then the last command that we had in this [program]

Is output command?

And so that the opcode for that, you know we decided was just going to be 1 1 1 0

So we'll just do that here that's 1 1 1 0 will be the instruction that gets loaded if we want to use the output

Command and again that has the same 3 steps in this case the output command is is quite quite

Straightforward it just takes the contents of the a register so a out and it puts it into the output register, so output register in

Is right here?

And that's it it only needs one [more] clock cycle. So these last [2] clock cycles are just unused

And you might be able to imagine some ways that you could optimize the computer to skip those in certain cases, but for now

We won't worry about that

So I'll just fill in the rest of these has all zeros

[now] you might notice this is starting to look a lot like [a] truth table where we have inputs over here on the left

which are the instruction register and the step that we're on and then we have outputs which are the you know the control signals and

In fact that's [exactly] what this is this is a truth table

that defines the logic that we need to build [for] the rest of the control logic and so you can imagine there's several ways we

Can we can built this one is we could build this logic from discrete logic gates

so you could say ok well these are my inputs I've got you know seven inputs and

15 Outputs

And let me design [a] circuit using you know and gates and or gates and inverters and [nand] gates and all the rest

That actually defines this logic, and you could do that and if you go back and look at the video. I did on building a

7 segment display decoder

You know I did something similar there. It was a bit less complex than this

and that [got] pretty complex, but you may also [remember] that we were able to simplify that by using maybe eeprom and

In fact if you look at this you might think well this this would be very easy to do with an eeprom because you've got

These 7 bits over here that are inputs and you can imagine those being the address

Into a location in the [erm]

And then these 15 bits over here you can imagine being the contents that are stored [be] prom

And that's exactly what we're going to do with this computer the problem of course is that the e probes that we've been using are

Are these?

28 C 16 [any] problems [I'm] going to continue to use those for the control logic as well

But you remember you know got. What is it? Yeah a lot of address lines going in here, and of course we only need seven

And there's only eight

Data pins, [so] there's only sort of eight outputs

And [then] farms the address lines go to that [TD] enough

We can just set the rest of them to zeros as far as the outputs go well there's only eight outputs

but we can use two chips to get eight outputs from one and then eight outputs from the other and that's kind of why I've

Divided these like this so that [we'll] have half of the control word in one of the chips

And the other half of the control word in the other chip

And then as far as the instruction and step those will be the address inputs to both chips

We'll just feed that into both of them. So now to actually build that to add those ee problems into our circuit here first

I'm going to get rid of this sort of temporary

[setup] that. I had here with this inverter. We're not going to need that since we're going to replace all that functionality with the [eeproms]

and also going to

Disconnect all of these jumpers that I was using to manually set the control words because we're now going to be able to use

The the control logic that we're about to build so we get all that out of the way

So I had to eeproms here and the first thing I'll do with each of these is just hook up power and ground

Now if we look at the pin [out] for these chips there's a couple other things

We want to make sure we hook up

We've got the right enable output enable and chip enable and we want to make sure each of those is set properly

so right enable it all of these are active low and

So we want right enable we don't want to be writing to the chip we only ever want to read from this once

It's you know in the circuit here

So we want that to be high because we don't want to write and then output enable and chip enable we want to be low

Because we do want the output enabled and we do want to chip enabled. So set write enable

High on both of these and then output enable low, so it's active and then chip enable is also low

so that's also active now the address lines for each of these chips is going to come from the instruction as

Well as the step because those are kind of inputs if you will to this to this truth table

So those are going to be address lines, and so there's only seven bits therefore for that address

And each of these chips has a has a tone an 11-bit address