Placeholder Image

字幕列表 影片播放

  • So in the previous video we took a look at what it would mean to execute a program on this computer

  • And we wrote this program that says to load data into the a register from whatever's in Memory address 14. Which was a 28 and

  • Then add the contents of Whatever's in Memory address 15

  • Which is the number 14 to that and then output the result so it's outputting the result of those two numbers added together?

  • and we saw that each of these instructions is actually made up of

  • Several different steps and each of these steps is called a micro instruction

  • And we actually step through this program by manually setting the control words each of these control signals to either high or low

  • So in this case, we've [got] it

  • Set [to] a out and output register in which we'll take the contents of the a register and put it into the output

  • Which is the last micro instruction for the output instruction and to the way this would work is we would go through each micro

  • Instruction and set up the control word appropriately and then pulse the clock and so when the clock pulses

  • That's when that transfer actually happens

  • And so what the control logic that we're going to build here needs to do is to be able to set up the control word

  • appropriately for each of these micro instructions

  • between each of the clock pulses

  • So there's two things that we need to know in order to set up the control word

  • Appropriately for each micro instruction one of them is which instruction. We're executing

  • So load a 14 and then the other is which step [we're] on and actually we [don't] even need to know what instruction

  • We're executing until we get down to this fourth step because the first three steps you see are

  • The same for every instruction because that's what actually loads

  • The [hour] fetches the instruction from memory and puts it into the instruction [register]

  • And then when we get down here to the fourth step fifth step and in some cases a sixth step here

  • Then we need [to] know what instruction. We're executing but we have [we'll] have that in the instruction register that whole time

  • So we have that information, but the other piece [of] information

  • We need in order to know

  • Exactly how to set up the control word is which step were on so step zero step one step two three four and so on

  • Instead of do that. We're going to need

  • Essentially need a separate counter that we'll build for the control logic to count which step

  • We're on then we get to the end. We'll reset it

  • account again

  • So to keep track of what microinstruction. We're on in our construction cycle. I'm going to use the 74 LS 161

  • Which is a 4-bit counter and we use this in the program counter of the computer as well

  • But it's got the clock input and then four outputs

  • Which will count in binary from 0 to 15?

  • So this is a lot of time up to 16 micro instructions in each instruction cycle

  • Which will be more than enough to handle any of the instructions we're going to build for this computer

  • So here's a 74 LS

  • 161 so just add this down here is the first part [of] our control logic, and I'll connect power and ground

  • And then pin 1 is a clear line

  • So we don't want the chip to clear so we'll just tie that high which will keep it from from resetting to zero

  • And [then] pin 9 is a load, which [is] also active low

  • So I'll tie that to to high as well

  • and that will prevent it from loading in a

  • Different value from these inputs and then we're just going to leave these inputs disconnected which we're not going to use those

  • So tie the load high so it's not loading

  • And then pin 7 and pin 10 are enable lines and so we also want [to] tie both of those high so that the outputs

  • are enabled

  • [since] all that out of the way

  • We now have our outputs in our clock so as we pulse the clock the outputs [should] count so let's hook up some leds to

  • These outputs, so we can see that

  • So just hooked up the first three because I don't think we're going to need to count all the way to 16 with this what?

  • Is actually going to be more than enough?

  • So [3] bits will be enough for that

  • And [so] now I'll just hook the clock up to the [computer's] clock and see if this counts

  • so the clock input is pin 2 here and

  • It's probably bouncing a little bit there, but if I start the computer clock

  • We'll see it starts to count in binary and so here you can see is that a computer clock is pulsing

  • The counter down here is counting away, and so that will count and keep track of where we are in our micro instructions

  • So if it's 0 we're here 1 2 3 4 and

  • So [on] and if we don't need to use all of the cycles here, we can just do nothing for the last few

  • But you might remember in the last video [and] we were stepping through this by hand what I would do is I would

  • to the control word

  • And then pulse the clock and then set up the control word for the next micro instruction

  • and then pulse the clock and so really what we want is we want the control unit to be changing the control word between

  • clock cycles and

  • Right now this is changing on the same clock cycle

  • That would be changing everything else and so we almost want two clocks that stay in sync, but where the control logic is is

  • Updating just before the the main clock is pulsing and the way we can do that is actually just by inverting

  • The main clock so conveniently as part of our clock logic. We have a 74 Ls 0 4 which [is] an inverter

  • There's actually six inverters, and we're only using take two of them

  • So there's a spare inverter up here that we can use to invert the clock

  • [so] [we'll] take the output of the clock into one of the

  • Inverters here, and then if we look at the output of that inverter

  • I'll just look an led up here

  • you can see that if you think [about] when the led turns on

  • this one turns on then this one turns on then this one turns on and that's perfect [for] what we want to do with the

  • Control logic right because we want the control logic

  • to set up when this one turns on and then we want the computer to [actually] execute that step when this one turns on and

  • Then we want to go back and forth and back and forth so by inverting the clock that will give us another clock that is

  • Perfect for what we want to do with the control logic?

  • So I'll go [ahead] and connect this inverted clock down to the micro instruction counter in the control logic

  • And so you can see now this is counting, but it's counting between the clock cycles

  • Actually, I'll move this [led] down here. So it's easy or see

  • And so now you can see these clocks are alternating and this one is updating sort of between

  • These clock pulses if that makes sense now [in] addition to counting and having a binary representation of which micro instruction run

  • It's also going to be useful to to decode that

  • And so I'm going to the 74 LS. 138 that's going to decode it so that we can take that three bit binary value and

  • Translate that into having a separate signal [that] indicates whether you know which of the instructions

  • We're on for which of the micro instructions. We're on so I have a 74 LS 138

  • Hookup ground and power, and then this has several enable lines, so these two are active low

  • And then there's one [that's] active and all of those have to be set properly for it to be enabled

  • So [we'll] set these to tie these two to ground and tie [this] one high

  • 10 4 [&] 5 to ground and then pin 6 is high and

  • Then the input is this select a b and C. So that will go to the 3 bits here that we're using to count

  • So there we go

  • We've got our select there and then our

  • Outputs are just going to be here along the top so 0 through 6 and then 7 is down here on the bottom

  • So I'll just hook up some leds so we can see what's going on with those

  • as I've just hooked up the first [six], but you can see that as this count 0 1 2 [3] 4 5

  • 6 7 0 1 2 [3] 4 5 and then 6 and 7 if I had those leds hooked up you see this counts along

  • And we'll keep track of which of the micro instructions were on so if we're executing

  • one of these instructions

  • If we if we need to know if our logic is going to need to know which of these

  • Steps were on we've broken that out now

  • And we have a separate signal that tells us 4 on each of those steps the other thing

  • We can do is we can use one of these outputs to reset the counter because right now

  • This is [counted] the counter is counting up to [eight]

  • I'm actually it's counting to 16, but we don't have the fourth led hooked up, and this is only decoding 3 bits

  • but it's but but if we want to reset it like let's say we want to reset it when it gets here instead of

  • counting 7 & 6 & 7 go back to 0 so it's going 0 1 2 3 4 5 6 7

  • 0 1 2 3 4 [5] and at that time it's spending on 6 & 7

  • Are really just kind of wasted the computer is not going to be doing anything?

  • So it'd be nice if we could just reset this counter and get back to 0 as soon as it gets up to

  • 2 6 and so we can do that by instead of tying the reset here of the 74 LS 161

  • Which is pin 1 is is this clear pin instead of tying that?

  • To [2] 5 volts all the time so it's never resetting we could tie it up to one of these outputs

  • So let me take this out and tie this over here, too

  • I'm going to tie it to the last output

  • Well [-] to this output [here]

  • So I tied it to output five here until what's happening is it going [zero] [one] [two] three [four] and then when it gets to?

  • Five this is actually going low although you can't see [it] because it's the instant it goes low

  • that resets the counter and the counter goes back to zero so zero 1 2 3

  • 2 0

  • 0 1 2 3 4

  • [5] and then [zero] again because as soon as it hits 5 it resets and goes to zero and so now

  • This is only counting up to 5 it's going to 0 0 1 2 [3] 4 0 1 2 3 4 so

  • It's really only counting to 4 so we're only getting essentially [5] steps out of the 0 through 4 and then it immediately resets

  • so that actually wouldn't work in this case because add has 6 steps 1 2 3 4 5 6

  • But of course we can move this over to this last pin

  • Which they don't have an led hooked to but is is the next output?

  • And so now you can see as soon as it gets to the end it resets

  • And so this is counting you know 0 through 5

  • It's counting 6 steps. Which is which is the most that we'll need for any of the instructions that I'm planning on it

  • So now the combination of having this counter here it shows us which instruction or which which part of the instruction cycle

  • We're on along with having the instruction itself that gets loaded here into the instruction register. We've got all the information

  • We need to properly set the control board bits

  • And so really the only missing piece is [some] combinational logic

  • And you could you know I've got a video where I talk about how you can replace any

  • Combinational logic with an eeprom and so I hopefully if you watch that video you can [imagine] how you could use

  • Some ee [proms] to take this counter information and this

  • instruction itself as

  • inputs to the address lines of the e eeprom and then the data outputs of the [eproms]

  • Could directly feed the control word over here and just by programming the right things into that a eeprom you can create whatever

  • Instructions you want to for this computer and the computer will be done

  • Now I'm planning to do something a [little] bit more sophisticated [over] the next couple of videos

  • To talk about how you can write micro code

  • And essentially a little bit nicer way of organizing the control logic

  • But just to kind of get get a sense of how this this could work

  • The fetch cycle for each of these instructions is the same and so really for the first three steps

  • It doesn't matter what's in the control or is what's in the instruction here because we haven't actually loaded that instruction yet

  • But these first three steps are going to be the same and so we can

  • we could build some very simple logic to just look at what step are on and

  • Turn on the appropriate control signals if I want to just demonstrate that right now so for example the first instruction in

  • the first micro instruction in the instruction cycle for for every instruction is

  • this counter out memory address register in

  • Step and so that's that happens in Sort of time T0 and so we can we can give each of these

  • Steps a a name so t0 t1 T2 T3 T4 and T5

  • And so this T0 step

  • For every instruction is going to be counter out memory address register in so we can actually hook this signal here which is t0?

  • Straight up to those

  • Signals there of course we need to invert it because this signal [that] we've got here is is the inverse of T0 to the t0?

  • complement

  • So we need just stick an inverter in here and again. This is just kind of an example demo

  • This is how I'm going to actually build this control logic

  • but just to demonstrate we can hook an inverter up here and we can take the T0 signal or the

  • complement of the T0 signal into the inverter and then the output of that inverter

  • We just stick an led here

  • Oops, my tower was not hooked up, [Cori] Right--let's there. We go

  • And so now you can see the [led] comes on whenever we're in T0, and so when we're in t0

  • That's when you want

  • We really want the counter out and memory address register in signals to be active and so instead of this led here

  • I could just come out of this inverter and

  • Go into the counter out wherever that is let's go over here

  • Let me turn these other things off here first. We can say counter out

  • And so you can see on t zero now the counter out

  • Signal is active. Let's get that label there

  • So counter out is now active on to zero and then we also want

  • Which was it?

  • Memory address register in which is over here

  • So maybe what I'll do pull that out bring this here, and then just jump over from my address register in over the counter out

  • really dudes

  • There we go, and [so] this is kind of a temporary thing to demonstrate this but you can see [now] on Time t zero

  • We've got the counter out and memory address register in

  • Active at the same time and so that's t zero, so this is this is t zero here this first step

  • T one is ran out in instruction register in and in the comments on the last video a lot of people pointed out that

  • You could probably do the counter

  • Enable which Increments the counter the same time that you do the ram out instruction register in because those things are not related

  • And I agree we could actually do that and then

  • This would actually become t one to do all three of these

  • things

  • It actually saves us a step right so instead of needing for example for this add 15 instead of 80 one two three four five

  • Six steps we could do it in five because this would be a single step so one two [three] four five

  • And actually that also reduces the the total number of instructions that any instruction the computer would need so this is a really good optimization

  • So let's give it a try let's say for for time t 1 we're going to do [ram] out instruction register ian and counter enable

  • so again

  • We'll need to go through this inverter right so t 1 here will go into the inverter and then coming out of the inverter

  • We want to go to ram out which is here as well as instruction register in

  • which is here and

  • counter enable over here and so now you can see for time t 0

  • We get our memory in and counter out and then full time t 1 we get ram out selection registering and counter enable

  • If we watch the operation of the computer now you can see at t 0 and t 1 we're setting the control [wording]

  • We're actually moving things around so you can see that the the program counter is incrementing here

  • You can see that that program counter is is making its way over into the memory address register

  • And if we speed up the clock a bit

  • that'll happen even faster, and you can see it's also starting to fetch things from memory and put them into the instruction [register] and

  • [a] lot of memory doesn't have anything in it

  • But once we get to an area of memory that has some things you can see those things are getting moved into the instruction register

  • for for each of the instructions

  • So I'll slow it down here

  • And so now you can see that instruction is sitting here for so we load a new instruction

  • But then for time 2 2 [3] [4] [&] 5 that instruction is sitting here in in the instruction register

  • So that we could build some logic here. It looks at the instruction [that] we've loaded as well as what like what part of the

  • Instruction cycle we're on so we know which micro instruction to to actually set

  • And so I'll get into that in future videos where we'll talk about how to actually build this logic

  • You know of course this inverter here. This is all just kind of temporary just to demonstrate

  • the fetch part of

  • [executing] a program, so if we speed this up again, you can see we're

  • Going through memory and loading those instructions one of the time into here to execute each instruction

  • So this is just temporary in Future videos. We'll use the eeproms to

  • to

  • implement a combinational logic

  • But [I'm] going to do something a little bit fancier

  • to to make it to kind of organize the way that the eeprom is a program a little bit better so that it's easier to

  • To do the sort of micro programming which is writing these these micro instructions to Define

  • What instructions the computer actually is able to interpret now one other nice thing about combining?

  • the ran out instruction registry and the counter enable into a single step is that

  • instead of you know, I think [ad] 15 is our is our most complex instruction with 1 2 3 4 5 6

  • Microinstructions that if we combine this it's only [five] micro instructions, and if that's the most complex

  • Instruction that we have in the computer. We don't need all six steps here

  • we can actually reset the counter at

  • T4 by moving this over here and so now when it gets to T4 it resets

  • And that actually makes all of our instructions execute faster because they take five steps instead of six steps

  • And so that six step would make it you know 20% take it make each instruction

  • Take 20% longer, so this is a really nice optimization to combine those things

  • And I think we can then just get rid of that extra step

So in the previous video we took a look at what it would mean to execute a program on this computer

字幕與單字

單字即點即查 點擊單字可以查詢單字解釋

A2 初級

8位CPU控制邏輯。第二部分 (8-bit CPU control logic: Part 2)

  • 2 0
    林宜悉 發佈於 2021 年 01 月 14 日
影片單字