But how does it work what electrical signals does a computer need to send into this thing in order to get a picture to show?

Up. Now this connector has 15 pins, but aside from some grounds here actually a bunch of these pins are ground

There's only five signals that we really care about. There's red green blue horizontal sync and vertical sync

some of these other pins are sometimes used in different ways for the computer and monitor to communicate about what

Resolutions the monitor supports things like that, but those are all optional. It's been just ignore everything but those five pins

anyway

This works is pretty closely tied to the way old-school CRT monitors worked

and those old monitors you had an electron gun pointed at the screen with

Electromagnets around here that could deflect the electrons to different parts of the screen

Then to paint an image the electron beam just scans across the screen from left to right and top to bottom or so

That's not actually how it works in a modern flat panel monitor

but the timing of that electron beam

physically sweeping across a screen is still what defines the timing of when we need to send each pixel and we don't just need to

Worry about the order of the pixels and the time from one pixel the next there are also these margins on the top and bottom

left and right

For the electron beam to to sort of have a chance to stabilize or you can think of it coming up to speed

Before it paints the next scan line

Then it blanks and has a little extra room on the right here before the beam swings back to the left

Which also takes time for the beam to swing back to the left?

To start the next scanline and then same thing at the bottom of the image

There's some blank scan lines down here before the beam gets sent back up to the top left for the next frame

And so there's this physical process that the timing is based on

So even though a more modern monitor doesn't use the same physical process

We've got to follow the same timing in order to get an image to show up

And so this diagram shows the detail of what that timing looks like

The visible part of each scanline takes some amount of time and that's followed by what's called the front porch

Which is just a blank time on the right side of the image

Then you get the sync pulse

which is a separate signal line this horizontal sync signal

That tells the electron beam to swing back to the left side of the image

And then the back porch is the blank time on the left side of the image before the next scanline starts

And then it's the same at the end of the entire frame. So you get to the end of the frame. There's a front porch

Which is the time to account for blank scanlines down at the bottom of the image and then a vertical sync pulse

Which is the signal and on also the time that it takes for the electron beam to get sent back up to the top left

Of the display and then there's a back porch which accounts for blank scan lines that are at the top of the next frame

But what matters here is that for any particular display resolution the monitor supports we've got to get these timings right

So the horizontal sync and vertical sync signals are the are pins 13 and 14 on our connector here

We've got to get the timings of those signals right in order for the image to show up properly

And in fact with older CRT monitors if you didn't get the timing right

you could actually damage the monitor because you could get the electron gun pointing somewhere where it shouldn't be pointing and I don't think it's

Possible to damage newer flat panel monitors, but if you do end up damaging your monitor

I don't wanna hear about don't blame me. Actually, I do want to hear about it, but don't blame me

Okay, so getting the timing right is important, but what are the exact timing requirements?

Well, if we look out VGA signal timing you can see in this first link

there's a whole bunch of different resolutions and different modes and

A good video card would support a bunch of these resolutions and maybe even communicate with the monitor over some of those data pins

I said to ignore to pick the best mode, but my goal is not to make a good video card

My goal is just to get something working

So, you know, I'm looking for one of these modes

You know any mode that I think's gonna be easiest to build hardware for and you know, there's a bunch of trade-offs

So depending how you think about it. You might come up with a different choice and that's fine

But you know

I figure I want to avoid the larger resolutions here because it's just a lot more image data to worry about

and you know

Then I'm just looking at the different pixel clock frequencies here

Since I'm going to need to build a clock that runs at one of these frequencies

And these are all in the tens of megahertz

So that probably means using a crystal oscillator of some sort and I've got a bunch of crystals with different frequencies

and of course

None of them are any of the frequencies we want

And I also have some of these integrated crystal oscillators can things that you can just hook 5 volts up to and it spits

Out a nice clock, in this case, this one's 10 megahertz

But unfortunately, nothing I have matches any of these clock frequencies. However, I can actually use a slower pixel clock

As long as I compensate by sending fewer pixels

So for example, I could use that 10 megahertz oscillator here instead of the 40 megahertz pixel clock

But of course, you know timing is still critical, you know

I can't change the overall timing

But the times that matter here are these times here and there based on the pixel frequency

But they're also based on the number of pixels

Right, what really matters is how long does it take to draw each scanline. How much time do we spend in the display

How long is this front porch, how long is this sync pulse in terms of time and so forth

So that's what matters and that's what these times are here

So this 20 microseconds of how long it takes to draw the visible area of one scanline is based on having 800 pixels

Divided by 40 million pixels per second, and that's 20 microseconds

But if instead of a 40 megahertz clock we're using a 10 megahertz clock

Well, 200 pixels divided by 10 million pixels per second is still 20 microseconds

And so the timing will still work out and then same thing with the front porch

the sync pulse in the back porch right is

If our front porch we get to 200 pixels here and we keep going another 10 pixels

Well 10 pixels divided by 10 million pixels per second is 1 microsecond

And so that that front porch will take the right amount of time

And then same thing with the sync pulse if we just keep counting another

32 pixel times

32 pixel times divided by 10 million per second is 3.2 microseconds. And so our sync pulse will be exactly the right length

And so as long as we divide all these pixel numbers by 4 and conveniently, they're all divisible by 4

We use these numbers. Our overall scanline is still going to take 26.4 microseconds even with this 10 megahertz clock

So that's what I'm going to do. So I guess to start out

What I'm going to do is build a circuit that's going to count pixels because we need to know where we are

We need to know, you know, are we at pixel 0 or we at pixel 50?

When do we get to pixel 200? When when are we in this range here where the sync pulse needs to be below?

So to do that I'm going to build a counter that will just count pixels and then when it gets to 264

We'll reset it and that will count the pixels horizontally

And then we'll end up building another one to count where we are in terms of which line we're on

And so to count the pixels, I'm going to use the 74LS161

And because we've got to be able to count all the way up to 264

That's going to take nine bits and the 74LS161 is a 4-bit counter

So in order to get at least nine bits, I'm going to need three of them

I'll start by connecting the power and ground pins for each one

So I'll just kind of go through each of the pins and hook them up

So the clear pin is what's going to reset all of our counters to zero

So we want to be able to clear all of them at the same time once we get to 264

So I'm just gonna tie the clear pins together for now and then the clock pin is kind of the same way that they're all

gonna use the same clock

So I'm just gonna tie the clock pins together for now

And eventually I want to connect that clock pin to our 10 megahertz oscillator

But I'm gonna leave it out for now

Just because in order to test it

I wanna be able to run it at a slower speed to start with so next we have our data inputs

And we're not gonna use that because we're never gonna load a value into this. We just want this to count

So I'm just gonna leave all those disconnected, but the enable pins, we do want to be connected

So I'm gonna connect them all high so that the chips are always enabled

Then again because we're not using these inputs for anything the load pin over here. We we don't want to use that either

That's an active low. So I'm going to tie them all high and then this other enable pin and this enable T

I'm going to enable the first one

But the other two I'm not going to always have enabled because this is actually how the ripple-carry works

So we're going to count the first four bits on the left here and then we want it to roll over and count the next

Four bits here and then roll over and so forth

And so the way that works is we connect the ripple-carry

output of the first chip to the enable of the second chip and then the ripple-carry out but if the second chip will connect

To the enable of the third chip and that way we've cascaded these together

So that we will be able to count actually 12 bits because there's you know four there four bits each

But we really only care about the first nine bits

And so that should be all we need in order to get a counter going

So what I'll do is connect the outputs up to some LEDs so we can see if it works. So there we go

I've got the first 10 bits, even though we only really care about the first 9 bits got the first 10

But it's hooked up to those LEDs if we power this up. Well, nothing happens because we don't have our clock yet

And we just hook our 10 megahertz clock up. We're not going to see anything

This is just gonna be counting so fast that just looks like all the LEDs are on

Now for a slower clock I could use a 555 circuit like I've shown in a previous video

But actually what I'm going to do is use this fancy signal generator since it'll give me a lot more control over the exact frequency

And so we want to set this up for a square wave and then the high level will be

5 volts and

Then we need to set the low level and that'll be 0 volts so that way we'll get a square wave that goes from 0

volts to 5 volts and then the frequency here is

1 kilohertz and you know, that seems fine

We'll start there and so I'll hook the output of the signal generator up to our clock input here

That'll go right into our clock for all 3 chips

and so now if I turn on the signal generator

And there we go, it looks like it's counting but it's counting pretty fast now we can slow it down let's try 100 Hertz and

That's not working as well, but you know what

Our clear is not actually they're hooked together, but they're not actually hooked to ground or 5 volts

So I think ground ground clears it but if we look at the 5 volts, there we go

So it was just sort of clearing itself because that was floating

But now you can see it's counting in binary

Which is what we want and we can slow it down even more if we want to

But really what we want to be able to do is we want to be able to know when we get to these different time

points here

So we want to start counting at 0

But then we want to know when we get to 200 if we want to know when we get to 210

When we get to 242 and when we get to 264

And then actually 264 we want to reset it back to zero. Well, how can we tell that?

Well to figure out when the counter gets to 200, you know, we're counting in binary

So this is going to be the the binary equivalent here for 200

So all of the bits are zeros except for these 3, right?

We've got the 128 place the 64s place in the eights place and net that makes 200

So we have these signals

That look like this those 3 ones that are set and we want to be able to detect when we get here

what we can do is we can actually

Invert all the bits that are supposed to be zeros and not invert the bits that are ones and then over here on the right

All of these are going to be ones when we get to 200

Then what we can do is we can just feed all of that into a NAND gate and the output of that NAND gate will

go low only when all of the inputs are high and all those inputs are going to be high or all of those inputs could

Be ones only when our counter over here is actually at 200 and you may noticed. I only hooked up eight of the bits

There's this ninth bit who's kind of hanging out up here

Well, that's because we can use the 74LS30 which is an 8 input NAND gate

But it's it's only 8 inputs. And as far as I know they don't make a 9 input NAND gate

that's actually ok because looking at these 8 bits is actually enough to know that we've gotten to