Cookies   I display ads to cover the expenses. See the privacy policy for more information. You can keep or reject the ads.

Video thumbnail
So in a previous video we used an eeprom as a decoder for a seven segment display
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
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
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
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
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
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
So if these are both zeros and we want to display the ones place
and so if we put in for example if we put in the number 123 here, we'd want the output to display a 3
but if we set a a high if we put in 0 and a 1 for a 9 and a 8
Then we want this to display the tens place for that same number so again if we've got 123 let's say here
Then we want to display [a] 2 so that would be the tens place
Then if a 9 is a 1 and a 8 is a 0 then [we'd] want to display a hundreds place for whatever is in
Here so again if this is 123, [we'd] want to display a 1 so again just as an example here
This is what we would actually want to see programmed in the eeprom for example
so at address 0 0 0 and then this [0] 1 1 1 1 [zero-one-one], this is this is the binary for
123 in decimal and
So because we've got [two] [zero] [zero] here
the output is going to be the bits that we need to set in order to show a 3
But if our input is that same set of bits in the lower eight bits, so this is still representing the number 123
but in this case if we've got a [0] [1] in these upper bits
Then we want to output something different one output the bits that we need in order to display the number two on
[the] 7-segment display, and then same thing here for the hundreds place if a nine is one and [eighty-eight] is zero and
The rest of these are the same this is still representing the number 123
Now we want to output whatever we need to output to display the number one this case is just these two segments
And then you know because we've got four digits. There is also this case
We have to handle where we've got a 1 and a 1 in a 9 and a 8 and in this case
We'll just output nothing so all [zeros] will just mean none of the [segment's] are on so that fourth display
I'll just be blank, so this is what we want to program
So we don't really want to just type out all [of] those because that's that's going to be you know over a thousand
Separate numbers, and we don't want to we [don't] want to type all that out like this
so let's write some code that actually just fills in all of the numbers that we need to program into the eeprom so I am
Going to use this this part here at least up [to] number nine. Yeah, so this this part here
I'm actually going to copy that and then we'll comment that out and then down [here]. Let's see
We don't need to erase the whole eeprom
we're just going to be writing over a lot of this anyway, so I'm going to delete this code and
Then here when we program the data bytes rather than just programming whatever was in that Data array
[we] call this digits
so these are just the the hex codes that we need in order to display each of the digits from from 0 through [9] and
So we want to start by programming all of the ones place so we can go from address
0 to 255 and we'll do right right [eeep] rom address and
then we
[want] the the digit that corresponds to the ones place for that address so to get the one place of the address we can do?
address Mod 10 and this % is the Modulo operator which
Essentially just divides a dress by 10 and gives you the remainder, so if a dress is 0 we divide by 10
the remainder is 0 if
address is
123 we divide that by 10 we get 12 with a remainder of 3 and so it'll you know so this will give us 3
Which is the ones place in 123 so this will give us whatever the value of the ones place is for a dress
But we we don't want to write that we want to write the the digit for that
So what we can do is we can just use this as an index into digit
so if we say digit
and then at that index because this
This address mod 10 is always going to be a number between 0 [and] 9
Because whenever you divide something by 10 the remainder is going to be between 0 [and] 9
So that's always going to be a number between 0 9 and so that's just going to give us whichever of these values
Corresponds with that position
So this should write all [of] the ones places to the [eprom] next we need to write all the tens places
So we'll go from 0 to 255 actually address is probably not the best name for this let's call this value
Because the value in the address are only the same for the ones place
So I'll just rename all these value to be consistent and so here
We're going to write to value Plus
256 is
The address that we're going to write to and that's because we're doing this case here where we're doing the the tens place and so
a 8 is always going to be set and the value the place value of
This bit is 256 so it's going to be whatever the value is plus
256 and that's the where we want to program the tens the you know [does] [a] appropriate code for the tens place
And so here we want to get the tens place
And so if we do address or not address value oops actually this [should] be value mod 10, so if we do value
Divided by 10 because value is declared as an integer here this divided by 10 will be an integer division
So it won't give us a decimal place
It'll just give us a truncated value
so if it's 123 and we divide by 10
If these give us 12 it won't give us 12 point 3 and so if we take that and then we do a mod 10
We'll get the 2 for the tens place and so again
we can use that as an index in two digits to get the
appropriate code to display that digit
So we'll write that and then we want [to] do the hundreds place, and it's going to be the same thing
So we'll just go through all
256 values in this case
they offset as 512 because we're writing now to this range here where a nine is set in a eight is not set and
The place value [of] in binary of a nine is 512 so we just make sure [we] just add that to whatever our value is
To put it in that address
So value Plus 512 and then digit we're going to index into digits for value
Divided by 100 to get to hundreds place and then mod by 10 although that's probably not going to be necessary because we're only going
from 0 to 255 so this should only be 0 1 or [2] but we can do that anyway for consistency and
So this will write all the [hundredths] place and then for that fourth digit because we do have four digits
We just want that last one to be blank so we can do a loop that [just]
Writes all zeros to that range, so this will be value plus
768 Because both A
9 and a 8 are set so you take the 256 plus the 512 and you get 768 and
Then for that whole range. We're just going to write all zeros because we don't want that digit to display anything
we'll just write all zeros and
We don't need this loop to write our data
So we'll do that, and then you know we can still print the output there
So let's upload that
and it's programming and it's done and
Well, we just printed the first 255 bytes here, but you can see this should just be repeating the [first] 10
Things over and over again, it looks like it. Maybe is but yeah, let's give this a try
Let's pull this out and put it into our
Circuits we get the eeprom back in the circuit hook up power
And we see [it's] cycling through to zero and blank but of course it's not putting the numbers on to the individual displays
It's just showing them in sequence. Which is not quite what [we] want, but we're getting there, and so if we give this another
number so let's say we give it that example like [that] 123 and you see three [two] one blank three two one blank and
So what we want is we want the three here the tool here the one here and the blank there
So what we need is some way to sequence through these
Displays and for that what I'm going to do is I'm going to use our
Counter to then feed into a decoder so to do that. I'm going to use the 74 LS
Which is a two to four line?
decoder or D multiplexer and so what it does is it's got two inputs say 1 and b 1 and
Depending on what those values are you get one of these data outputs?
Goes low and so basically you can imagine just this a and B
We're going to use our
counter here which is counting from 0 through 4 and I nari we're going to use that a and B and
It's going to cycle like this from both being low to a being high then b
Then both so that's what we've we've already got that [and] then what happens is the outputs it just cycles each of these
Going low in turn so just cycles to each of those and then what we can use this to do is is select which
Output digit, we're displaying, so [the] way this chip works is pretty simple
It's got the two inputs and it's essentially just using a series of [an] gates and inverters
To pick based on how these inputs are set which output to turn on
So if we put with 74 or less 139 up here, it's pretty simple to hook up
We just need to give it power and ground like we do with all [of] these and then it has an enable pin here
Pin 15 that's active. Low, so we want that to [be] active. So we'll type in 15 here to ground and
Then the inputs are just [pins] 14 and 13
And I'm just using the top one because we're coming from from over here
So stay on that side of the board so I'll just hook these two
To those inputs so now let's take a look at the outputs which are on pins 9 10 11 and 12
And so you can see the outputs of this decoder
You've got all of the outputs on except for one and the one that goes off corresponds to our input as we're counting
This is very convenient and [is] also the reason that I used the common Caso displays
what we can do is we can hook these outputs up to the cathodes here rather than just [hi] all the cathodes to ground and
That way the only cathode that will actually be hooked to ground
Will be the one that we want to be displaying for example instead of connecting the ones place
Cathode directly the ground to this resistor if I connect it to this first
output here
You'll see the ones place is only on
When we're displaying that three and the three is what should be in the ones place, [so] in other words
we're both displaying the correct digit and
Putting the correct address into the eeprom to display that place value at the same time and so I can do the same thing for
the tens place instead of connecting that directly to ground
through that resistor I can connect it to
the second
sitting here
And so now you see the one the tens place only shows up when we have a two there and remember the input here is
is 123
So we get the two in the tens place?
We get the three in the ones place just as we should and then the hundreds place
Same thing rather than connecting that directly to ground we can connect it to this place here, and so now we only see the one
When we're addressing the location in the eeprom for the hundreds place, and then finally [this] fourth digit
We can do the same thing although
We shouldn't see much there because remember we programmed all zeros
Into that last block of memory and so now we've got the right digits in the right places
but this isn't quite what we want right because we want our display to actually show us a
Number we don't want to have to read it like this
This is kind of kind of Janky, but [what] we can do is adjust the speed of our clock
and so if I replace the 100k resistor with a 100k potentiometer [I]
Can start to increase the speed by turning that potentiometer?
And what you'll see is as it gets faster and faster
it looks more like 123, and if I go fast enough
You can't even tell that it's flashing like that
So that's basically our display now instead of sticking this pot in here. I'm going to put the hundred K resistor back
So now another way to slow this down is instead of using this 2 Micro Farad capacitor. I'm going to replace that
With a 10 nano farad capacitor instead and that's going to give us a similar kind of effect and with it running this speed
We don't really need any of these leds. They're not showing us anything interesting so I'm going to pull all those out as well
[I'm] also going to clean up these wires here and just replace them with wires that are cut to length
And so there we go
We've got our 8 inputs here
and we can switch these two different values and
We get the decimal representation of whatever input is down here on our display
Now we've also got this last address line that
We could do something interesting with so right now if we take that [high] we just get all ones on everything because we haven't programmed
The other half of this chip so we could actually have two different
types of display we could program the first half of the chip the way we have four decimal display and
Then the second half of the chip could be programmed with some other kind of display
It could be hexadecimal if you want to do that
What I think would be interesting [and] since we have this fourth digit is
You could program the second half of the chip to show negative numbers or more specifically you could you could have a decode two's complement
numbers which could be positive or negative two's complement uses an 8-bit number to represent numbers from between
Negative 128 up to a positive 127 and [so] we can use this first digit to show the negative sign if we need to
So to display in in two's complement. We want to basically do the same thing, but instead of
Right now we're programming values from the Rivermen memory locations essentially from 0 through
10 23 because this is going to be 255 plus 768 10 23
So we're programming simply the whole first half of the chip with our normal
Unsigned integers and so for the signed integers that use the two's complement. We're going to start at
Memory location 1024 so to program that we're going to want to go value from negative
128 oh you know what I just realized we might have a bug because look at this we're going from zero [to] values less than
255 so we might not actually be programming
255 so let's let's actually give that a try. Let's go back here
Set this to here and let's try looking at position 255. I bet it's not programmed properly
so if we go to
Let's see that's 254 and if we change this to 1. Yeah look at that. We didn't program 255 because
we said less than
255 so we need to do less than or equal to for all of these
I'm glad I caught that
Now if we come back down to here so our value is going to go from Negative 4 to
[complement] our value is going to go from negative 128 to positive 127
Our our address is going to start at 1024
[but] we don't want to add value to it right because values start to negative 128 so if we add that to
1024 we're actually going to be writing
[partway] into into this
Area before so what we can do is we can take
Value and cast it to a byte. So what this will do is it will take
Value and treat it as an unsigned byte
So it's if value has negative 128 in it then this will say well negative 128 is represented as a byte as 1
followed by seven zeros because that's how
yeah, because this is going to use two's complement to represent that so this should take value and and
Using a tooth compliment convert it to an 8-bit byte
Which which should be a positive number?
And then we'll use that as our as our address and then what we want to write there is
Essentially the same thing as we have here digits
For value Mod 10, but what I want to do is I want to take the absolute value of this
So if it's you [know] that's negative 123 then this will take the absolute value of that and give us
123 and before we mod by 10 and look at the last digit if now I can move on to the tens place again
It's going to go from 128 to 120 or negative 128 to 127 and basically the same thing
But of course we're going to divide value by 10 first 2 gets tens place and our base here instead of being
1024 is going to be 12 8 right it's 1024 plus 256 and then for our hundreds place
We can just copy this again, and so this will be divided by hundred to get our hundreds place and this will be
1280 Plus 256 which is
1536 and so that'll be our hundreds place
And then we just need to do that fourth digit there which before we just set all [zeros]
But in this case we could use [that] to
Represent our sign by setting a negative sign there until we want to do is if if our value is negative
so if value is less than
Zero, so if it's negative then we want to write to our address
so take value and cast it to a byte to get a positive two's complement representation of our value and
Then here are off that's going to be 1536 plus 256 which is
1792 and so if it's negative we want to write
a believe a 1 right, so one should be
This should be the one
That last bit should be segment g which which is the one in the middle that would look [like] a negative sign?
Otherwise if it's Nonzero we want to write to that location plus
1792 in [this] case we [just] want to write [0] we want to display to be blank if it's positive
[and] I think that should do it
Yeah, and I'm going [to] add one of the things. I'm just going to add some
Some print lines here so we can just keep track of what it's doing well
It's programming because it's programming the entire a eeprom where we're programming all all
2048 memory locations into CD promised over it's going to take a little while
So I'll add these print lines so that it's easier to see what's going on [ok] so
that should be it, so let's go ahead and
upload this
Ok our serial monitor, and this is taking a little while speed this up for you, and it's done
So let's pop the eeprom back in our circuit here, so if you got our 255 here
So that's fine, and so this should work [just] just normally so you know if we set some other values here
127 Or you know 123 122
123 so this is this is working normally
And these values obviously are lower than 128, but if we go up to you know 251 that's going to be positive
[so] because we've got this bit low, but [if] we want to look at our two's complement, and we set this bit high now
We're looking at two's complement. So anything below
127 Or 128
should be the same so any of these other values should be the same if we set this high bit now to
Something now. We've got a negative number, so this is negative 13
So let's see if we're in binary and we put in 1 1 1 1 0 0 1 1 in binary
We convert that to decimal we get 243 and so that would be normally what it is
So if we go to our normal mode so yeah, that's 243 if we go to two's complement
Yeah, negative 13 so that's right. So we are getting we are getting the right thing
And we can try some other things let's just I'm just going to move these around to just sort of some random
Things we've got negative 46 in there. I don't know negative 62 let's say
so this is
1 1 0 0 0 0 1 0 so
if we go to decimal yep, negative 62 and then if we're in unsigned mode
That should be 194 [yep], so it looks like this is programmed right and working now
We've got an option where if we set this low
We have a normal sort of unsigned mode, so this this will just represent numbers from 0 to 255
But if we set this high then our output will show us numbers from negative 128
Up to 127 and depending what we're using the computer for we may want one of those
Output modes or the other and we can set that using this this input here
So I [think] they're pretty much does it for our 8-bit display here
so we've got [8] bits coming in and we're able to display it either is a
Signed two's complement or unsigned and we did it with only a single 28c 16
ye prom So I
think that's quite an improvement over the last time I built one of these where I use three of these one for each digit and
we've got a
Two's complement signs mode as well