Placeholder Image

Subtitles section Play video

  • In a previous video we built this circuit that generates a valid VGA signal, and when we plugged a monitor in

  • we saw that the monitor recognized that it was in 800 by 600 mode.

  • And that's because we're sending at the right horizontal and vertical sync pulses for that mode.

  • We're sending a 3.2 µs horizontal sync pulse 38-whatever thousand times per second and

  • we're sending a 0.1056 ms sync pulse

  • 60 times per second. And the way this all works is we have a binary counter here that's counting from 0 to 264

  • you know over and over again, and it's counting at exactly 10 million times per second.

  • So we can look for these particular values to get the pulse width and the pulse frequency

  • to match exactly; and then same thing in the vertical direction, you know

  • we've got another counter here that counts each line on the screen from 0 to 628

  • and of course, you know

  • we measured all the timing and everything in the last video to make sure it matched the specs and it did and

  • so we saw the monitor recognize it as a valid signal. So if you want to know more about what's going on here,

  • I definitely recommend you check out the first video, but now you know

  • we probably want to actually display something on the screen.

  • And to do that, the VGA interface has a few more signals for red, green and blue. and

  • Because we're using the sync signals here to stay synchronized with the monitor

  • we can use our horizontal and vertical counters to keep track of what part of the screen the monitor is currently

  • "painting" at the moment. And so the 0 to 200 tells us where it is from left to right, and then the 0 to 600

  • Will tell us where it is from top to bottom and so as the monitor paints the screen

  • You know, left to right, top to bottom: the same way you'd read a page in a book.

  • These red green and blue signals is how we tell the monitor what colour pixel we want at that particular location.

  • In other words: because we're synchronized, we can use our counters to know exactly what pixel the monitor is.painting at the moment

  • So for example if I take just one bit from one of these counters

  • (so this is the the vertical counter) if I take those, you know 1 2 4 8 16s place

  • Let's say this 16 s placed bit right here

  • you know as we count down the screen from 0 to 600 down the screen this bit is going to flip on or off every

  • 16 scan lines.

  • So if I take that bit and hook it up to the the green signal and I'm hooked it up through a

  • resistor (for reasons that I'll get into here in a minute)

  • There we go

  • You know

  • You can see every 16 lines the green flips on and off and that's because as our article counter counts from 0 to 600

  • every 16 counts this

  • 16 places bit flips on and off because that's how binary counters work

  • Now if I hooked the red up here to the eights place in the same way

  • There we go

  • and now you now you can see the green and the red as well as

  • Yellow when the two mix and then of course, you know, I can also hook up blue

  • So, let me just do that for the sake of completeness

  • And now you can see the three primary colors mixed to give us actually 16 distinct colors

  • but you know as much fun as colorful stripes are what I really want to do is display a more complex picture and

  • for that to work

  • We need the pixel data stored in some memory somewhere

  • Normally in a computer the data for whatever's on the screen is stored in a part of RAM

  • that way the software running on the computer could just write new data to the same Ram location and the image on the screen will

  • Change right away, but I'm not gonna hook this to a computer at least not yet

  • So I'm just gonna store the image on an EEPROM and this is a 28 C

  • 256 EEPROM so it'll hold 32 k of data which should be enough for an image of some sort

  • and the way this will work is we already have our horizontal and vertical counters giving us an x and a y

  • position and if we feed all of those signals into the addresses of the

  • EEPROM

  • Then the EEPROM will give us a byte stored at that address and that byte could be the color of the pixel for that particular

  • XY location

  • So that's how we'll store the image in the EEPROM

  • But there's one weird issue which is because we went with the 10 megahertz pixel clock instead of 40 megahertz

  • we only have 200 pixels by 600 instead of 800 by 600 and

  • 200 by 600 is kind of a weird resolution

  • No

  • The pixels would be kind of stretched out because really what we're doing is we're repeating each pixel four times as we go across

  • So it'd be nice to maybe slow our vertical counter down. So we repeat each line four times as well

  • And it's actually pretty easy to do if we have our counter counting in binary like this

  • You know here we're just counting 0 1 2 3 all the way up to 16, you know, just counting in binary

  • Well, if we lop off that last bit

  • now it goes 0

  • 0 1 1

  • 2 2 and so forth up to 8 and if we lop off another bit

  • Then it repeat each number four times and only counts up to 4 instead of counting to 16

  • So if we just ignore the bottom 2 bits of our Y counter that all divided the counter by 4

  • We actually still have another problem which is the EEPROM. I have the

  • 22:56 it actually only has 15 address lines so we couldn't fit all these address lines here

  • Even if we wanted to so we've actually got to get it rid of at least three address lines in order

  • For it to actually fit in this EEPROM

  • So given what we've got with this EEPROM and to keep the right

  • proportions end up having to drop three bits from our Y counter and one bit from the X counter and that leaves us with a

  • Final image resolution of 100 pixels by 75 pixels which you know, I don't know it's maybe not the most impressive resolution

  • But I mean, what do you want for me? I'm trying to build a video card on bread boards

  • So 100 by 75 is is what we get. So let's hook the EEPROM up like this

  • I'll start by adding another breadboard and connecting power and ground to the EEPROM

  • Then I'll tie the right enable pin high since it will only be reading and it's active low and

  • Output enable and chip enable are both active low as well

  • So I'll tie them both low, so everything's enabled for output

  • Then the first seven address lines go down to our horizontal counter

  • and again

  • We're skipping the first bit and the next seven address lines go to the vertical counter and this time skipping the first three bits

  • So that's 14 address lines 7 for X 7 for Y. There is a 15th address line, which we're not going to use

  • So I'll just tie that to ground

  • So now we've got all of our address lines connected like this

  • So for each of our 100 by 75 pixels, we should be getting a byte of data out here

  • That'll presumably tell us what color that pixel should be

  • But how are we going to turn this 8-bit data into the signal that the VGA monitor expects?

  • well

  • the VGA interface has three pins red green and blue and each expects a voltage between zero and point 7 volts and

  • Depending on what that voltage is

  • Whether it's closer to 0 volts are closer to 0.7 volts

  • Determines how much of each color is mixed together to determine the color of the pixel?

  • But we've got eight bits here of data that are either 0 volts or 5 volts. How do we get something that's point 7 volts

  • well is the case where we have one voltage and we need a lower voltage and so we can use a voltage divider and

  • A voltage divider is just two resistors like this. So relative to ground down here

  • We've got 0 volts and up at the top. We've got 5 volts and in the middle here

  • It's going to be somewhere between 0 and 5 volts and how far it is from 0 volts to 5 volts

  • Depends on how big r2 is compared to the total resistance

  • So if r2 is half of the total resistance that is r1 and r2 or the same value then in the middle here

  • We're gonna have half the voltage. So two and a half volts if r2 were 10% of the total resistance

  • Then we'd have 10 percent of the total voltage or half a volt

  • So this expression just describes that?

  • You look at the proportion of r2 to the total resistance

  • And then that tells you how much of the total voltage you get

  • Now the VGA spec says that the red green and blue signals it says, you know zero to 0.7 volts

  • It also says it's got this 75

  • ohm input impedance and

  • You can roughly think of that as meaning that inside the monitor

  • Those red green and blue inputs are kind of connected to ground like this through a 75

  • Ohm load of some kind

  • so if we've got five volts and we want to get it down to

  • 0.7 volts as it's going into the monitor here. We can just add a resistor like this and that creates a voltage divider, right?

  • So we've got five volts at the top

  • We've got ground here at the bottom and we want this to be 0.7 volts here in the middle

  • Now if the monitors input impedance is 75, ohms

  • we can't change that but we can put whatever resistor we want here between our 5 volts and the input to the monitor and

  • You know to figure out what resistor that needs to be in order to get 0.7 volts

  • well, we could just look at this expression here and say you know

  • When would this expression equal 0.7 volts given that r2 is is going to be 75, ohms

  • well, we can put

  • 75 ohms in here for r2 and set it equal to 0.7 volts and we just need to solve for R

  • So 5 times 75 is is 375 and then R + 75 times 0.7 is gonna be 0.7 R + 52 and 1/2

  • Subtract that 52 and a half from both sides we get 0.7 R

  • Equals 3 22 and a half we can divide that by 0.7 and we get R equal to four hundred and sixty point seven. Ohms

  • So if we take five volts and we put it through a four hundred and sixty point seven

  • Ohm resistor will have point seven volts here going into our monitor, you know given that there's a 75. Ohm load inside that monitor

  • But ideally we don't just want point seven volts or zero volts going into the monitor here, you know

  • ideally

  • we'd be able to have a range of voltages between zero and point seven volts so we can get different brightnesses of red green and

  • Blue, yeah, so that we're able to have different shades of colors

  • so for example

  • If we wanted four different voltages from zero at 0.7

  • Evenly-spaced so we could get four different shades of red green and blue

  • We'd have to solve this equation essentially for each of those different voltages to find out what resistor we need to get that particular voltage

  • So that's what I've done here. That's what these different resistances are and

  • This is for you know, one-third brightness two thirds brightness, and then of course full brightness at 0.7 volts

  • Which is what we just we just figured out is four hundred sixty point seven

  • And we could use these different resistances to get these different voltages so that we end up with these different

  • Brightness levels for each of the colors and of course, you know, they don't make fifteen hundred fifty five point four

  • Ohm resistors they make you know fifteen hundred. Ohm resistors and they don't make

  • 720 two point nine. Ohm resistors, but you know, I've got 680 ohms which is maybe close enough

  • So if we use those resistors to build something like this that's got two inputs over here that can be you know

  • Either 0 or 5 volts and an output over here and check this out

  • You know if both inputs are zero like this then the output table. These are going to be 0 volts, right?

  • But if one input here is 5 volts

  • So the one hooked to the 1.5 cave' resistor is 5 volts and this is a zero then essentially we're kind of in this scenario

  • Here where we have, you know, approximately 1,500

  • 1,500 ohm resistor and we're gonna get about

  • 0.23 volts over here

  • But if we flip that around and we we don't have anything here and we have five volts down here

  • Then we're going through the 680

  • Ohm resistor and we're gonna have you know about 700 or well we're gonna have about 0.47 volts

  • But then if we have ones on both of these inputs, so both of these inputs are 5 volts

  • Well, then these resistors are going to combine in parallel and to combine resistors in parallel

  • You use this expression here, which is sort of the sum of the reciprocal of the sum of the reciprocals

  • So to combine 1,500, ohms and 680. Ohms in parallel like this

  • It's going to appear as a single resistance from 5 volts to this point over here of 468

  • Which is pretty close to here and so we're going to get 0.7 volts, so

  • this takes two inputs that can either be 0 or 5 volts and

  • gives us the 4 different possibilities that give us these 4 different voltage levels from 0 up to 0.7 volts and

  • So with just a couple resistors

  • we can take 2 bits of binary data and convert that into one of 4 different voltage levels from 0 to 0.7 volts and

  • If we do that for red green and blue

  • we can use six bits of data coming out of our EEPROM to get four different shades of red green and blue which combine into

  • 64 different colors and so this is the mapping for those different colors

  • If you're familiar with these hex codes for colors

  • But you can see the last two bits here controls how much blue there is now the middle two bits controls

  • how much green there is and then the first two bits controls how much red there is and

  • Then this here is what those actual colors look like

  • And so those are the 64 colors that were able to generate with a circuit like this

  • So let's actually hook these resistors up to the outputs of our EEPROM and to here the 1.5 K resistors

  • And of course, there's three of them one for red green and blue and here are the 680

  • Ohm resistors and so hook the first two data bits up for blue

  • And the first one is going to go to a 1.5 K resistor and then the next one will go to a 680

  • Ohm resistor, then the next two bits will be for green. So go to a 1.5 K resistor and then to a 680

  • Ohm resistor and then finally the last two bits are gonna be for red

  • The 1.5 k resistor and the 680

  • Ohm resistor and then we just need to tie this side of the the resistors for each color together

  • So they'll do blue

  • Green and red. And so now over on this side we should be getting that voltage between zero and 0.7 volts

  • So now we can try hooking this up to the monitor again

  • So here's our 15 pin vga connector and i've got the the same sync signals before in the ground, of course

  • But now i've got the red green and blue hooked up to pins 1 2 & 3

  • so we can hook up ground and hook up our sync signals as before so the horizontal sync and

  • The vertical sync and then the colors we could just hook up over on this side of the resistors

  • So there's blue there's green and there's red

  • now if we power up our circuit and plug in the monitor

  • So we basically see the same thing as before so the monitor comes alive

  • so it's detecting the sync signal but it's still a blank screen and

  • Of course, that could be because what's in the EEPROM is just blank

  • But I happen to know that this is an erased EEPROM and when you were to race an EEPROM it it just writes all one's

  • So we should actually see a white screen and we're not

  • but I think the problem is that if every address in the EEPROM is

  • Set to all ones then

  • We're gonna be outputting a white for every position and that includes even in the blanking time here

  • And we really shouldn't be putting out any pixels in this blanking time because well it should be blank

  • And in fact, this is one of those things that might actually damage a CRT monitor and hopefully we won't damage my monitor

  • But the way we can fix that

  • Is use these signals that were detecting here for the blanking intervals, right?

  • Because we're actually detecting when we're in this horizontal blanking interval

  • Right here with this flip-flop and we're detecting when we're in the the vertical blanking interval down here

  • So really what we need to do is we need to figure out are we in the blanking interval and those together?

  • and we could actually use the result of that for the output enable signal for our EEPROM so we can essentially turn the output of

  • The EEPROM off if we're in that blanking interval

  • so what I'm going to do is add a NAND gate here and I'm using a NAND gate so that the output is

  • inverted because our chip enable or not our tripping well actually both

  • But the output enable which is the one we're going to use the output enable is active low

  • So that way if if two inputs here are high

  • then the output will be low and then the two inputs that we'll use is well look at if we're in the display period for