World’s worst video card? The exciting conclusion

July 30, 2019 posted by

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 horizontal and the display period for vertical so, let me hook up power and ground for our NAND gate and so the first input here is going to say are we in the horizontal display period So in other words, this is saying are we in this time here? and then the next input is going to say are we in the vertical display period So that’s going to say are we in this time here vertically? If the answer is yes if we’re in both of those then what we want to do is we want to take the Output of that and use that instead of just always tying our output enable low. So here we’ll say output enable Only when both of these conditions are true So now let’s reconnect our monitor and see what we get And that’s still not working But it’s possible that I’ve got these mixed up and so I’m actually outputting only during the blanking interval So, let me just switch this over to the inverted outputs on both of these And there we go now it actually looks like we’re getting looks like a white screen So if we want to display something a little more interesting then we’ve got to come up with a little more interesting image Let’s find an image. That’s nice and colorful. This looks good public domain. That’s perfect So I’ll download I guess, you know, we’re gonna reduce the resolution here quite a bit. So it doesn’t matter too much So then if I load that image up in Photoshop, we can resize it So we want our image to be 100 by 75 So 100 by well make it 114 by 75 and then we can crop it to 100 by 75 Okay, so there’s our image with the resolution that we have on our screen. It’s now we need to change the color modes Who are using indexed color and we want a custom palette? and So these are the 64 colors that we can produce with our resistor voltage dividers and they’re also in the in the right order so for example an index of 8 is this You know green color and if we have an 8 in our EEPROM then that’s going to produce that same green color So it’s pretty important that we have the right colors in here and we have them in the right order So if we apply that This is the image we get so those are the 64 colors that we support and it’s a 100 by 75 So that is that is the best our wonderful breadboard video card can do so, let’s go ahead and save this We’ll call it image dot PNG And if we actually look at what’s in that file if we see, you know, there’s more than just a pixel data, right? There’s a header here PNG. There’s you know appears to be some XML stuff in here So there’s a whole bunch of stuff in here that we definitely don’t want to write to our EEPROM so what we’ve got to do is we’ve got to convert this PNG data into the pixel bytes that we want to put into our Indoor EEPROM and the best way I can think to do that is just with a little Python Script, we can use a Python image library to make a little bit easier. So pale is this Python image library And we can open up an image file and then we can load the image and when we load the image what we get is we just get a two-dimensional array of the pixels and because we’re using index colors with 8 bits and You know, we’ve got our colors in the right order here with the right index values the pixels that we end up loading are going to be the values that we want to actually output from our EEPROM to get those particular colors So really what we want to do is we just want to write all those pixels to a file without any of the PNG header Information without any compression without anything like that We just want to write the raw pixels to a file and then we can write that file the EPROM That’s what I’m gonna do is just go through all the pixels. And since our image is 100 by 75 I’ll just go through all 75 lines and then go through all hundred pixels per line and then I just want to write the value of that pixel to a file so I’ll create an output file just call it image bin and we’ll just write to this as a binary file and What we’ll write to it is we’ll write a character that has the value of the pixel so the pixel is going to be coming from our pixels array and it’s just gonna be at the XY value that we’re at So if we run this that’ll create that image bin file And if we look at the image that bin file what we should see in here is we should see all of the pixels so, I don’t know if this looks like a bird to you, but One sign that we’re on the right track here is that all of these values in here are less than 64? Or while they’re in hex, but they’re less than 40 hex which is which is 64 So at least everything seems to be you know in the right range But this isn’t quite how we want to organize the data in the EEPROM because remember we’re using 7 bits for the exposition and 7 bits for the Y position and so because we have a hundred pixels per row We have this X counter that goes up to 99, but once it gets to 99 It doesn’t just go to 100 it goes back to zero and then we increment our Y position and so the actual address in the EEPROM will jump from 99 to 128 because these all go to zero and then this bit will be a 1 and that’s the hundred twenty eights place so in the EEPROM really even though we only have a hundred pixels per line on the screen in the EEPROM we want to take Up 128 pixels per line, but that’s easy enough. We can just for each line instead of a hundred we can just do 128 and Then because we’re writing that 128 times we’ll end up writing 128 things to the file. So let’s run the conversion again and we get an error so image index out of range and that’s because you know our image only has only has 100 pixels across so You know when we’re trying to get pixel 128 or even pixel 101 or 100 that pixel is not actually in our image So what we can do is we can just try to catch that condition So we get an index error when we try to get that pixel. That’s not actually part of our picture What we can do is we can still write to the file But the character will write to the file would just be I mean, it could be I guess we’ll just write a zero So let’s run that and now if we look at our image We still see the data but what we see is we see, okay This must be the first hundred pixels, and then we have a bunch of zeros that Pat it out to 128 and so you can see like this block here That’s the first line and then this next block here with all the zeros padding it out to the end That’s the next line And so this should be the format of data that we want to put into the EEPROM Now I suppose I could use the EEPROM programmer that I built in a previous video But in this case because I’ve got all the data in a file and everything already It’s probably easiest just to use a commercially prom programmer. It’s also a lot faster. Let’s pop our EEPROM out put it in the programmer Then I’ll use Mini Pro which is just an open source EEPROM programmer tool that works with this programmer and Will tell it we’re using the 1828 C 256 which is the EEPROM We’ve got and we want to write the image bin file to it and it says incorrect file size 9600 so that’s because I guess it’s expecting a file. That’s the exact size of the EEPROM and we have a 32 K EEPROM So we need to give it a 32k file And the reason our file is is smaller is because our Y is only counting from 0 to 74 even though you know This is 7 bits so it could go up to 128 And actually there’s an a 14 right that’s that’s this extra address line that we just tied to zero So there’s actually another 8 bits here So our Y value really could go from 0 to 255 But we’re only writing the first 70 75 values of that and that’s just so that our you know image aspect ratio makes sense We can do the same thing here. We can just change this to 256 and Then anything that’s out of range will just write a zero to the file So let’s reconvert and then if we take a look at our image file you can see the image but then if we go all the way down to the you know if we get all the way down at the bottom it says we have got a row of zeros and then I think this star just means everything is zeros between there and Eid 0 0 0 which is 32,000 So let’s try to write it again. And there we go. It’s writing it And so now let’s put our EEPROM back in and see if we get the picture of that bird Hey and there it goes and So this is our completed video card, but you know, it’s producing an image from the ROM. So I’m going to call that a success Well, you might notice these thin black vertical lines and I think that’s because the ROM I’m using is relatively slow. Yes I’m using a 10 megahertz clock which means it’s counting 10 million times per second or you know Once every hundred nanoseconds remember the monitor still assumes I’m using a 40 megahertz clock so really the monitor is expecting a pixel every 25 nanoseconds and So here’s the problem if we look at the data sheet for the EEPROM that we’re using There’s a delay from when the address goes valid. The address lines are valid to when the output is valid That’s this TAC C or access time and if we look at access time here the addressed output delay It’s a maximum up to 150 nanoseconds for the dash 15, which is the one I’m using Well 25 nanoseconds per pixel 150 nanosecond delay could mean up to six pixels could be invalid in this in this period from when the address changes to when the output is actually valid and you know It makes sense that sometimes invalid might just mean that the output is zero And so I think that’s why we sometimes see a few black pixels like this Now in a computer like I mentioned before the image would be stored in SDRAM Which is designed to be very fast access for this very reason And of course the you know the software running on the computer could write new data to that RAM and the image would change right? away whereas here the only way to change the image is to reprogram and/or swap the EEPROM which as You can see even if I speed it up when I edit. The video is is pretty slow But you know, that’s not really the point is it, you know Really the goal was just to get some kind of image on the screen and I’d say this is a success And if you want to try this yourself, you can head over to my website I’ve got schematics data sheets and where you can get all the parts and as always, you know I want to thank my patrons for making it possible for me to create videos like this as you can imagine these were rather time-consuming videos to plan out and produce and without the support of these people and all my patrons who are just viewers like you Making this kind of video just wouldn’t be possible. So, thank you

Tags: , ,

100 Replies to “World’s worst video card? The exciting conclusion”

  1. IronShark says:

    can I play GTA 5?

  2. Aron Highgrove says:

    Nice "subliminal" teasing flash of the breadboard computer 😉

  3. MeMad Max says:

    This brings back tons of memories lol

  4. Kfiat ooh says:

    Holly shift… till now I thought that my Arduino projects are impressive…

  5. psku says:

    For someone like me, coming without any background knowledge, I find this was exceptionally well presented and gave tremendous insights in how "stuff" works. Thanks!

  6. connor horman says:

    I’d write ff bytes where you are padding rather then 0 bytes.

  7. selfblumpkin says:

    This is unbelievable man. I've had a very rudimentary understanding of most of these concepts but you break them down in such a great way that I feel like i have an engineer's understanding of how this stuff works. Thank you so much 🙂 It's time to pull out my bread boards and start messing around again.

  8. David says:

    That ending though….

  9. LoL4476 says:

    Great video, as well as the previous one too!

  10. salveru ajay says:

    Can you make home cloud with hotspot

  11. G Guy says:

    I'm impressed with how simple and detailed the speech was. I watched cartoons in my childhood with characters was acting like "geniuses", but they looked not realistic. Creators didn't seem to understand science skill neither their characters did. This video represents real knowledge of problem and everyone can see something behind represented device. Something skilled and elaborate.

  12. Cruz Delacruz says:

    top drawer!

  13. PulsartGaming says:

    Can you make a video about USB cables and how they workout with multiple devices?

  14. derek jock says:

    I have no clue what the hell he is doing and it’s confusing but it’s so damn interesting to watch

  15. ReznoV Vazileski says:

    I can't wait to see somebody making hundreds of these and combining them into worlds slowest 4k GPU xD

  16. tichu7 says:

    Nice to see the Viewsonic finch make a comeback.

  17. Joanna Hammond says:

    hehe, working on my own version of an 800×[email protected] SVGA module atm. It's not as simple as it looks, especially if you have slower external clocks and you also want to read/write image dynamically to the onboard SRAM. Still got a bit of logic to work out and am restricting myself to 74 series (where I can) and only 2 layers on the PCB. Yep, I do like to make my life difficult.

  18. mateo ardila says:

    Outstanding work, keep it up!

  19. emb1234567890 says:

    Hi Ben,

    Thanks so much for your work on this project! Your breakdown of computer concepts at the circuit level really demystifies the magic of early computing. One thing that I’ve been wondering about is how this method of picture display originated. Seeing as CRT and VGA control signals operate off the same concept, it seems a natural extension to go back in time with this circuit. Do you think it would be within your abilities to make a simple homemade CRT monitor? I know that it’s not out of the realm of possibility to make cathode ray tubes at home, and it might be possible to rig up two electromagnets as the deflection elements. Idk how doable the fluorescent screen is, maybe more doable if the resolution is significantly limited. It would also give you the opportunity to show how the sawtooth waves that control the magnets could be generated in an analog way. This idea has been banging around in my head since the first part of this series, and I’d love to here your thoughts on it.

    Keep up the good work!

  20. Tim Derks says:

    These two videos were probably the most interesting videos I've watched in a long time. Awesome work.

    In a (three) related questions:
    – What kind of wires do you use on your breadboards, they look so neat and easy to work with
    – What kind of breadboards do you use?
    – If you use them, what kind of dupont cables do you use?

    I've been working with my own (cheap) breadboard stuff lately, and it bugged the crap out of me. I knew what I was getting into when I bought the cheap stuff, but still.

  21. Green Man Diary says:

    Wonderful evolution from the breadboard computer to this. It's neat that you & Grant both use Python to create your masterpieces.

  22. tberry7348 says:

    Love it!!!

  23. Tangobaldy says:

    Is your voice sped up?
    I tried playback at .75 and it sounds too slow but nearly ok when voice goes fast. I feel a play back speed f 90% would be perfect. Maybe you video software is set wrong?

  24. Thicc Boi says:

    But can it run crisis

  25. David McCurley says:

    Truly impressive work. I can see you showing this at a job interview and getting hired on the spot. How long did this take to produce?

  26. ryan.m says:

    sometimes, the world's worst graphics card is actually pretty cool

  27. n1ckcacam1s says:

    You should consider doing a bonus part 3 where you load 3 unique images into the remaining memory and slow the clock enough to make it animate like a GIF!

  28. Ahmed Gaafar says:


  29. smeezekitty says:

    I would honestly just connect up the unusued address bits. Aspect ratio doesn't really matter as long as your resize your source image correctly. Old video cards often had strange aspect ratios (like CGA had a 640×200 mode) and resolution is far more important than pixel shape

  30. Charles Blouin says:

    There is some extra space on this ROM. With a divider on the clock, you could even play a video! Nian cat on breadboard?

  31. Edmond Hung says:

    Will it be easier to do this on a FPGA?

  32. Against NAZO! says:

    pfff…, why videocard? I watch the matrix encrypted

  33. DaVince21 says:

    This was fascinating to follow from start to end. I'm not familiar with breadboards at all but this makes me want to experiment with them.

  34. Abhijeet Vishwakarma says:

    Damn, this is really amazing.

  35. Mark Woodworth says:

    This is so fascinating. We take all the stuff that happens "behind the scenes" for granted, but it's really amazing to see how complicated it all is (or simple?)!

  36. Sad Little Octopus says:


  37. Boring Old White Guy says:

    Best breadboard based video card build I have ever seen on youtube. 🙂

  38. JONOVID says:

    awesome stuff! so why not make an 8 bit digital camera ? or
    or publish you own how-to book of your DIY 8 bit Computer schematic diagrams, so we can all make your circuits!

  39. lollllloro says:

    It seems you could just write the shorter file by adding the -s switch; from minipro man page:
    -s Do NOT error on file size mismatch (only a warning).

    minipro -s -p AT28C256 -w image.bin

    Or alternatively either pad it or append to it:

    truncate -s 32768 image.bin

    dd if=/dev/zero bs=$((32768-9600)) count=1 >> image.bin

  40. Christian Hall says:

    Hell yeah man. Thanks for the video. Learned a lot, and I'm excited to try something similar!

  41. David Taylor says:

    Great explanation of the voltage divider required for the output, and then combining resistors on the top side of the divider to get two different levels. I read an article about this recently and didn't understand it.

    Is this the same thing with speakers where there are 4 and 8 omh ones and you can damage them if you give the wrong input?

  42. Cucumbulous says:

    tfw you forget that you can also save as .bmp and write a python script to convert a .png to a .bmp…

  43. Benjamin Brooks says:

    Please plug it into an actual CRT!

  44. y2ksw1 says:

    Yeah, old stuff … 40 years ago or so … nice to see it again, though 😊

  45. Nathan Reed says:

    Could you add your eprom data writing circuit with the arduino into this to output different frames one after another?

  46. BrendaEM says:

    You realize, of course, that you are quite mad.
    I am really enjoying these videos. Thank you : )

  47. fernwood says:

    Your videos are so amazing. Would it be insulting to call you the Bob Ross of breadboards?

  48. Imam Bux says:

    Ben… I just found out your channel. It's the best. I am a Soft. Engg. Is there anything you could do for us. I am sure whatever the category would be, it will help us alot.

  49. Я Супер Стар says:

    i think it may be useful with PC parallel port. If develope the drivers and hardware converter

  50. Я Супер Стар says:

    What is that was at 3:03 seconds of video?

  51. Sauraen says:

    The Patreon thanks via EEPROM images was a nice touch!

  52. Abid ahammed says:

    Wow you are genius

  53. Sad Violin Man says:

    HEY BEN important question! is it possible to add this module to your 8 bit computer and use it ? print results to the screen? or write a program that computer outputs images from eeprom which adreses came from the memory we programmed earlier ? How can we intagrate this module to the computer….Can we add new instructions for this module ? how would feed this into bus , do we need registers , too many questions 🙂

  54. Otto May says:

    Gouldian finch! Good choice

  55. Damisi Msanii says:

    this guy also knows photoshop…GURU

  56. aty14 says:

    (clap clap clap clap clap) j’applaudis

  57. Stephen Myers says:


    This awesome. Breaking it down to the fundamentals shows how really simple things are in the world of computers. Most people only see the 100 layers built on top of these core concepts that have been built up over the years resulting in smartphones and photoshop. But at the end of the day, it comes back to some very basic concepts.

    Great job !

  58. Jonathan B says:

    My mind is blown and I want to learn how to do this!

  59. phyrexkasgaming says:

    Maybe try to fine-tune it so it could maybe render some UI or so, I know that is very hard to achieve

  60. 私の顔にペニスを撃ってください says:

    can u make it a real gpu?

  61. Just Jack says:

    I continue to be very impressed by your skills. Thank you for this, absolutely awesome. Is there anyway you could eventually do interrupts/IVT or block device access? It would be pretty amazing to have it boot something like Minix

  62. Sontapää11 Jokulainen says:

    18:33 "I dunno if this looks like a bird to you".I died.

  63. pusheen says:

    I've just received most of the components for the 8 bit computer. There are a very few things I couldn't find in the store I ordered from but I'm gonna get them later from somewhere else. All I want to say is thank you for these excellent videos, you are the best!

  64. Artur Strzępka says:

    Hey, I saw Your video on reddit and got really interested in stuff you're posting. I'm trying to complete my first order with electronics part and I stopped at one thing. I wanna buy some logic gates microchips but I saw they're divided to two main cetegories 4000 and 7400 series. Could you please explain what are the main differences for a beginner like me and which ones should I focus on if I don't have any expectations except 'make it work'?

  65. Barry Manilowa says:

    I guess memory back in the 80s was too expensive to waste on video RAM.

  66. Lucas Emanuel Resck Domingues says:

    You should know that it's illegal, guy

  67. Paolo Lucchesi says:

    You could use truncate to obtain a file of exact dimensions

  68. Sentient Meatbag says:

    Amazing work, Ben! You are going to tear open that nVidia/AMD duopoly!

  69. Kasey Boles says:

    Those two unused bits could be used. Set each color up with three resistors. One unsused bit could be the lsb of green (the human eye is more sensitive to changes in green) and the other the lsb for both red and blue. Effectively a fixed 128 color pallet.

  70. Kasey Boles says:

    Also grab a faster, larger, eeprom for more resolution. There is a 128 bit 70ns eeprom that might work if he switches to a 20mhz clock. Assuming the rest of the ciruit is fast enough

  71. Octopus Ore says:

    Next challenge is to make it play YouTube videos

  72. Eden Rose says:

    id really like to see a 40mhz crystal used if you use this with your 8-bit build

  73. VoidMoth says:

    muh god …..

  74. Ercan Ulusoy says:

    Can it run GTA 5

  75. Tyler Page says:

    THIS IS SO COOL!! And so well explained. Thanks Ben!

  76. Tyler Page says:

    The endgame is he uses all of the computer components to upload a video of itself being made to youtube.

  77. Nicolas RK says:

    What a great work at many levels. Congrats!

  78. Animae says:

    Meanwhile, I'm having trouble getting a led light to blink.

  79. arban khan says:

    Sir do u have any notes

  80. Simon Tiger says:

    2:37 It's 8, not 16

  81. Junk Mail says:

    (***P**O**O**F***) Mind actually blown !!! Ben, I'd actually like to say a whole bunch more, but there ain't nuttin' left. Absolutely blown. Very, very enjoyable. Thanks.
    Student becomes teacher. Well done.

  82. Soumyajit Kushari says:

    Now that you have built an 8 bit computer and a graphics card, why don’t you try to make something like an apple 2? Use the graphics card to drive a display that would show the command line

  83. Mr. Birne says:

    amazing stuff!

  84. Suchipi says:

    So awesome 👏 thank you for making this!

  85. Diego Cárdenas says:

    I don't know why I watched this video, but I liked a lot

  86. grooste2009 says:

    hahahahaa wouw :). Love your project! Now building try my self! Want to use it on a arduino! I day I throw a way my windows box! Ahahahahahaaa.

  87. Paul van Lit says:

    Great video, you make it look so easy.

  88. Steven Hokins says:

    Cool series, Ben!

  89. D2RG6 says:

    Make a breadboard soundcard next

  90. CJWarlock says:

    Awesome! 🙂 The most amazing is the ability to pull wires of perfectly matching length out so fast. 😀

  91. MrSpaceboyy says:

    wow, never saw anything like your videos on youtube. Amazing

  92. Chris Limpens says:

    may i ask how you dit gain this knowledge of the 8 bit computer and stuff like this the videocard can u give us some guidance where to look for stuff like this or even where to start learning this outside of your video's.

  93. Luis Radiotecnico says:

    Es magico ver imagen de una señal digital grabada en eeprom

  94. Janky Shack says:

    Now do it out of relays! lol jk

  95. Peter Diggler says:

    so cool 🙂 Thanks!

  96. Steeve Bjornson says:

    any chance you could show us how to implement this with an FPGA?

  97. YouTube YouTube says:

    How about qwerty keyboard ?????????

  98. PRAVIN KUMAR R says:

    Possible to use this type of video card in our 8bit computer?

  99. James Parker says:

    the interesting thing is that this is more powerful than lots of the 8 bit computers from the 70's and 80's

  100. Jake Thomas says:

    "28Cxxx" = E2PROM – it's re-writable! The precursor to flash memory

Leave a Comment

Your email address will not be published. Required fields are marked *