so by hooking up a binary input here, so this is [6] or you know 4

5 by inputting a different binary number on the address lines of the eeprom the eeprom would output

Ones and zeros in the appropriate places to turn on or off the appropriate segment on the seven segment display

But how can we build a decoder for [8] bits that outputs a number from 0 to 255?

on three of these seven segment displays and

That question came up in the comments on the video about using an e eeprom as a 7 segment decoder

the YouTube Cuber asked what do I do if I have multiple seven segment displays is flying one decimal number and

There's some good replies in here

So rest little teapot says if I've got this correctly you would need one e eeprom for each seven segment display

And that's exactly what what we've got here? We've got one e eeprom for each of the seven segment displays

So we've got a one place a eeprom for the one stage at a tens place

for the tens digit and a hundreds place

for the hundreds digit and

Then the address lines or at least the first eight of the address lines for the chips are all linked together

So if we put an address value on these eight lines here in this case

I'm putting that binary equivalent of 123 that same value is going to show up on each of these chips

So this chip is going to be at address 123

This chip is going to be at address 123 and the chip is going to be at address

123 and so at that address for the hundred ship. It's programmed to display a [1] at that address for the tens chip

It's programmed to display a 2 and the ones chip is programmed to display a 3 and then they go on to [say]

Let's say we want to [represent] the numbers from 0 to 15

We can use 2 [e] [eproms] and this is this is exactly right here, so this shows for the address 0 through 9

That first the eeprom is just outputting all zeros and the second one

Outputs the numbers from 0 [to] 9 and then it wraps around here

And that first year you promised a 4 10 through through 15

And then Jason Masters here

[sort] [of] kind of restates that and then says

Yeah

if you link the address lines of the chips together so all the chips get the same address you put the binary number on the

address Line and

The output of the chips will display the decimal : that's that's a yes

That's absolutely right so simple

But then this is this is interesting the [YouTube] cuber again says another thing that I thought of is

multiplexing through the eeprom so you get the binary number and the digit number as input and

Then you get a you know binary coded decimal

or I guess you'd get the

Decoded set and segment [things] [as] your output and so you need a binary counter on the digit number input to [start] multiplexing

I like this idea rather than needing [to] have three of these [ee] problems one for each digit

We can do it with a single the eeprom that drives all three digits now

It's going to be a little bit more complex

But it's I don't think we're going to need to do anything that we haven't already done elsewhere in our computer build

So let's give it a try and I'll explain more about how those

Multiplexing works as we as we build out the circuit, so this display module is going to be part of our computer

It's going to [be] output for our computer

So I'm going to connect a new breadboard here right below the b register for a computer and build the display

Output here, and so we're going to use a single eeprom

that's the the idea of this multiplexing idea the 28 C 16 [I'll] start by connecting it to a

single [seven] segment display, and this is a

common cathode

Instead of common anode which were the ones we were using before so I'm going to connect the common cathode here to ground

through this 330 Ohm resistor and

There is the reason I'm using a common cathode

Display here which I'll go into later and so I'm just going to check the eight output pins for the eeprom to the seven

segments of the of the seven segment display plus the decimal point

And it really is just kind [of] hard to follow with everything on top of each other there

But basically what's going on is we've got these i/o pins [io0] [one] [two] [three] [four] [five] [six] [seven]

Those are the pins that are connected here, and they're connected to the seven segment display

basically like this

So you know this is what our seven segment display is going to do just zero through nine [since] we're just getting decimal at this

point and

each of the segments it has a letter designator, so

Abcde F and then g is the one in the middle

And then of course there's also the decimal point over here, and so this is the way that I've arranged the the bit order

So the decimal point is the most significant bit so that corresponds

With Io7 here, and then it goes

Abcdefg where g is the least significant bit corresponding with io 0 over [here]? So that's that's how I hooked this up

[but] of course you can hook it up any way you want you just got to make sure you know which bits need to be

On for each of the numbers that you [want] to display?

now we can also hook up power and ground for the eeprom so that [it's] powers and

Then the control signals that we've got we've got our chip enable our output enable and our write enable

And chip enable we want that to be active, so that's active low

Output enable we also want to be active, and that's also active low

and

Then write enable we don't want that to be active

We don't wanna be writing to this and so that's active low

So we want to tie that high so that we're not

Going to accidentally write anything to this chip and so that leads just the address line

So there's eight address lines over on this side, and then address eight nine and ten over on that side and for now

I'm just going to temporarily tie those all low

That's the first eight address lines are all tied low there and then I'll also tie the remaining three address lines over here

Low as well, so with all of the address lines tied low

This tip is going to be addressing address location zero and we'll see whichever bits are set on the output here

so let's add power and

We can see that. We're getting all the bits set so all seven segments plus the decimal point are on so

Address locations, they're on this chip is apparently programmed with with all ones and if we go to some other address so address one

Two so it looks like this chip is probably erased if all it's giving us is all ones on the output

So let's pull the chip out in and program with something

So I've got the eeprom in our Arduino programmer

And I'm going to come over to the code here and because we're using a common capital display now instead of a common anode

I'm going to make sure I've got the [right] programming for that

So this is the right bit that we want to have set for common cathode

so I'm going to add and upload that and I look at my serial monitor, and so it's programming and

Okay, it looks like it's going to start by erasing the eeprom and then it programs it and it looks like it's got that program

In there for the first 16 bytes okay, so let's pull it out and put it back in our other circuit

to put this back in here now and connect power

So now we've got a zero and if we go to address location one. We've got a one and

This is working as we would expect

but of course we want [to] have more than one digit and so [the] way the

Multiplexing is going to work is we're actually going to drive all the digits using the same data bits

And then we're going to switch on certain [digits] at certain times, which will hopefully make more sense in a minute here

So I'm going to add a couple more digits here

and what I'm going [to] do is I'm going to connect all of these essentially in parallel so that the outputs of the

Eeprom go to all of them in the same way

So I put all of the pinch of the [segments] together

[so] if we connect the common cathodes for each of these to ground we should see each of the digits light up the same way

Assuming everything is connected properly which

They're getting pretty crowded down here. So let me see what's going on here there

We go and so now if I change the input all three of these digits should change so there's one

three

Two and so on so of course this isn't what we want

But it does mean that we can control all of these digits from the one chip

And actually I've got a little extra room over here

So I can add a fourth digit if I want and I think there might be a way to use it

Because I think there will actually be a use for that fourth digit, which I'll get into later

but

now what we need to do is build the

Multiplexing logic that cycles through each of these digits so we can display a different number on each digit and the sequence that we need

a clock and I don't want to use the clock that is running the rest of the computer because

We might want to run that it if different rate or whatever so I'm going to build a separate clock just for the output display

using a five five five timer

Let me connect a five five five timer over here. I'll connect ground and power

And then I'm going to connect a 2 micro Farad capacitor from pin two to ground

I'm also going to connect 10 2 over 2 10 6

10 [five], I'm going to connect to ground with a 10 nano farad capacitor

and I'm going to put a 100k resistor between

thousand six and seven and then a 1k resistor [between] 10 seven and and five volts

between 10 seven and eight I guess

[10/8] is already connected to [five] volts

And so this is a simple a stable configuration

For the five five five timer and if I hope the the output which is pin three up to an led

Which is going through a resistor to ground. I should be able to see this pulsing so I connect power

There we go, so we have a little clock running here

And so next what we want to do is we want to use this clock to sequence through each of our displays and to do

That what we need is a small counter, so the 74 LS. 76 has got two Jk. Flip-flops on it

Which is just enough to make a simple two bit counter and we basically want to take [advantage] of the toggle

Functionality of the Jk. Flip-flop to build a simple counter so we want to basically just connect the preset clear J

And K inputs all high and then just use the clock every time the clock pulses

[we'll] get a toggle and we can use that [to] build a counter

So this is the preset and clear for the first

Flip-flop tying both of those high as

Well as the J input and the k input

Those are all tied high and then also the preset and clear for the second flip-flop

As well as the J and K inputs for the second flip-flop

and then of course this chip also needs power and

ground to power the chip so next we can connect the clock into our clock input for one of our flip-flops and

Then we'll connect the output of that flip-flop

into the clock input of the other

Flip-flop to create a counter so we'll connect the output of our five five five timer to that clock for one of the Jk flip-flops

And I'll connect an [led] to the output of that flip-flop and also connect the output that flip-flop around to the clock

for the other Flip-flop and finally I'll look at the output of the

[second] Flip-flop

So now if we power this up, hopefully, we'll have a working counter

And it looks like we do so we've got this counter now

So counting from zero one two three zero one two three

So that's counting from zero to three and so we can use that count to control which of our digits

We want to display to control that I can use to these additional address lines

So remember we've got our eighth address lines down here that we're using to put which value we want to show so right now

We're inputting a [2] and we're seeing twos

But we've also got these three additional address lines up here that we're not [using]

They're all tied to 0 we can tie two of those to these these counting

leds over here

So instead of tying this address line to ground I can tie it to this

Led here and instead of tying this to ground I can tie it to this led over here and

What you see is that when both of these are 0 we see the same thing? We saw [before] we see that [2]

So once every 4 clock cycles essentially we get a 2 here and then the other times

We're getting just all eight with the dots so basically all all of the bits are set

But what we could do is program this so that when the counter is at 0?

It's outputting the number we want in the ones place and when the counter is [1] it's outputting the number we want in the tens

Place and when the counter is 2 it's outputting the number we want in the hundreds place

So let's go ahead and actually program the eeprom to do that so again

I'm going to put the eeprom into our arduino eeprom programmer, and so just to summarize what we're trying to do here. We've got these

11 address bits

and

We're using the bottom eight of them a 0 through a 7 to input the number that we're trying to display

so this could be anywhere from all zeros all 1 so 0 to 255 and

Then we're using address 8 and address 9 to tell us which digit we want we want to display