VGA Signal In A Browser Window, Thanks To Reverse Engineering

December 30, 2019 by Donald Papp 25 Comments

[Ben Cox] found some interesting USB devices on eBay. The Epiphan VGA2USB LR accepts VGA video on one end and presents it as a USB webcam-like video signal on the other. Never have to haul a VGA monitor out again? Sounds good to us! The devices are old and abandoned hardware, but they do claim Linux support, so one BUY button mash later and [Ben] was waiting patiently for them in the mail.

But when they did arrive, the devices didn’t enumerate as a USB UVC video device as expected. The vendor has a custom driver, support for which ended in Linux 4.9 — meaning none of [Ben]’s machines would run it. By now [Ben] was curious about how all this worked and began digging, aiming to create a userspace driver for the device. He was successful, and with his usual detail [Ben] explains not only the process he followed to troubleshoot the problem but also how these devices (and his driver) work. Skip to the end of the project page for the summary, but the whole thing is worth a read.

The resulting driver is not optimized, but will do about 7 fps. [Ben] even rigged up a small web server inside the driver to present a simple interface for the video in a pinch. It can even record its output to a video file, which is awfully handy. The code is available on his GitHub repository, so give it a look and maybe head to eBay for a bit of bargain-hunting of your own.

Time Sync Through Your VGA Connector

November 10, 2019 by Jenny List 16 Comments

While it might be in its twilight years, the venerable VGA video connector conceals a versatile interface that can still provide the experimenter with the opportunity for a variety of hacks. We’ve not seen anything quite like [flok]’s one, in which he uses the VGA interface to insert timing information from which an NTPd instance gets its reference.

If this seems counter-intuitive because a VGA interface is an analogue output rather than a digital input, then you are correct to smell a rat. And he comes clean in his first sentence, as he’s not using the VGA lines themselves but the I²C interface that is a feature of all but the most basic of VGA cards. This is the means by which a plug-and-play operating system can identify a monitor’s capabilities, but there’s little to stop it being used for other purposes. In this case an Arduino fed by a 1-pulse-per-second timing signal from a temperature compensated crystal oscillator provides the I²C peripheral which is polled by NTPd.

This project should be of interest to any tinkerer because of its invaluable information on identifying and using the I²C interface on a VGA socket. So if you’ve used your VGA card as an SDR you might find it interesting, but hurry or you could have missed the boat entirely.

VGA plug image: Swift.Hg [CC BY-SA 3.0]

Hackaday Podcast 027: Confusingly USB-C, Glowey Displays, Logically VGA, Hackers Who Changed Gaming

July 19, 2019 by Mike Szczys 1 Comment

Hackaday Editors Elliot Williams and Mike Szczys dive into the most interesting hacks of the week. Confused by USB-C? So are we, and so is the Raspberry Pi 4. Learning VGA is a lot easier when abstract concepts are unpacked onto a huge breadboard using logic chips and an EEPROM. Adding vision to a prosthetic hand makes a lot of sense when you start to dig into possibilities of this Hackaday Prize entry. And Elliot gets nostalgic about Counter-Strike, the game that is a hack of Half-Life, grew to eclipse a lot of other shooters, and is now 20 years old.

Take a look at the links below if you want to follow along, and as always tell us what you think about this episode in the comments!

Take a look at the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!

Direct download (60 MB or so.)

Continue reading “Hackaday Podcast 027: Confusingly USB-C, Glowey Displays, Logically VGA, Hackers Who Changed Gaming” →

Pushing Pixels To A Display With VGA Without A PC

July 17, 2019 by Maya Posch 17 Comments

[Ben Eater] is back with the second part of his video series on building a simple video card that can output 200×600 pixels to a display with nothing but a VGA connection, a handful of 74-logic chips and a 10 MHz crystal. In this installment we see how he uses nothing but an EEPROM and a handful of resistors to get an image onto the screen.

The interesting part is in how the image data is encoded into the EEPROM, since it has to be addressable by the same timing circuit as what is being used for the horizontal and vertical timing. By selecting the relevant inputs that’d make a valid address, and by doubling the size of each pixel a few times, a 100 x 75 pixel image can be encoded into the EEPROM and directly addressed using this timing circuit.

The output from the EEPROM itself not fed directly into the monitor, as the VGA interface expects a 0 V to 0.7 V signal on each RGB pin, indicating the brightness. To get more than three colors out of this setup, [Ben] builds up a simple 2-bit DAC that allows for two bits per channel, meaning four brightness levels per color channel or 64 colors effectively.

See the video after the link for the full details. While pretty close to perfect, a small issue remains at the end in the forms of black vertical lines. These are caused by a timing issue in the circuit, with comments on the YouTube video suggesting various other potential fixes. Have you breadboarded your own version yet to debug this issue before [Ben]’s next video comes out?
Continue reading “Pushing Pixels To A Display With VGA Without A PC” →

ESP32 Gets Advance Windowed Apps Using This VGA GUI Library

July 8, 2019 by Ted Yapo 38 Comments

We featured [Fabrizio Di Vittorio]’s FabGL library for the ESP32 back in April of this year. This library allows VGA output using a simple resistor based DAC (3 resistors for 8 colors; 6 resistors for 64 colors), and includes functions for PS/2 mouse and keyboard input, a graphics library, and many of the miscellaneous functions you might need to develop games on the ESP32. Now, a GUI interface library has been added to ease application development.

The GUI, of course, runs on the VGA output. The library includes what you’d expect from a minimal windowing GUI, like keyboard and mouse support, windows with the usual minimize/maximize/close controls, and modal and message dialog boxes. For input controls, there are labels, text boxes, buttons, radio buttons, checkboxes, normal and editable combo boxes, and listboxes — you know, pretty much everything you need to develop a modern GUI application. All the code is open-source (GPL 3.0) and in the GitHub repo.

While the original FabGL had a game-development orientation, the addition of this new GUI functionality opens up a new range of applications. If you want to find out more about using the FabGL library, you can check out our previous coverage of the mostly game-oriented functions.

You can get a look at the new GUI functions in action in the video, after the break.

Continue reading “ESP32 Gets Advance Windowed Apps Using This VGA GUI Library” →

Low Res Video Card Is Still Amazing Since It’s Made Out Of Logic Chips

July 7, 2019 by Brian Benchoff 33 Comments

[Ben Eater] has been working on building computers on breadboards for a while now, alongside doing a few tutorials and guides as YouTube videos. A few enterprising hackers have already duplicated [Ben]’s efforts, but so far all of these builds are just a bunch of LEDs and switches. The next frontier is a video card, but one only capable of displaying thousands of pixels from circuitry built entirely on a breadboard.

This review begins with a review of VGA standards, eventually settling on an 800×600 resolution display with 60 MHz timing. The pixel clock of this video card is being clocked down from 40 MHz to 10 MHz, and the resulting display will have a resolution of 200×150. That’s good enough to display an image, but first [Ben] needs to get the horizontal timing right. This means a circuit to count pixels, and inject the front porch, sync pulse, and back porch at the end of each horizontal line.

To generate a single horizontal line, [Ben]’s circuit first has to count out 200 pixels, send a blanking interval, then set the sync low, and finally another blanking interval before rolling down to the next line. This is done with a series of 74LS161 binary counters set up to simply count from 0 to 264. To generate the front porch, sync, and back porch, a trio of 8-input NAND gates are set up to send a low signal at the relevant point in a horizontal scan line.

The entire build takes up four solderless breadboards and uses twenty logic chips, but this isn’t done yet: all this confabulation of chips and wires does is step through the pixel data for the horizontal and vertical lines. A VGA monitor detects it’s in the right mode, but there’s no actual data — that’ll be the focus of the next part of this build where [Ben] starts pushing pixels to a monitor.

Continue reading “Low Res Video Card Is Still Amazing Since It’s Made Out Of Logic Chips” →

Logic And EEPROMs Bring VGA To Life, Sans Microcontroller

July 1, 2019 by Dan Maloney 9 Comments

For whatever reason, the Video Graphics Array standard seems to attract a lot of hardware hacks. Most of them tend to center around tricking a microcontroller into generating the signals needed to send images to a VGA monitor. We love those hacks, but this one takes a different tack – a microcontroller-free VGA display that uses only simple logic chips and EEPROMs.

When we first spied this project, [PH4Nz] had not yet shared his schematics and code, but has since posted everything on GitHub. His original description was enough to whet our appetite, though. He starts with a 27.175-MHz clock and divides that by 4 with a 74HCT163, which has the effect of expanding the 160×240 pixels image stored in one of the EEPROMs to 640×480. Two 8-bit counters keep track of horizontal and vertical positions, while the other EEPROM takes care of generating the Hsync and Vsync signals. It’s all quite hackish, but it works. [PH4Nz] tells us that the whole thing is in support of a larger project: an 8-bit computer made from logic chips. We’re looking forward to seeing that one too.

This isn’t the first microcontroller-less VGA project we’ve seen, of course. Here’s a similar one also based on EEPROMs, and one with TTL logic chips. And we still love VGA on a microcontroller such as the ESP32; after all, there’s more than one way to hack.

Thanks to [John U] for the tip.