Hacking VGA for Trippy Video Effects


Ever since flat panel LCD monitors came on the scene, most old CRTs have found their ways into the garbage or into the backs of closets. For this project, it might be a good idea to pull out the old monitor or TV out and dust it off! [James] has found a way to hack the VGA input to these devices to get them to display vivid visualizations based on an audio input.

The legacy hardware-based project is called RGB.VGA.VOLT and works by taking an audio signal as an input, crossing some wires, and sending the signal through a synthesizer. The circuit then creates a high-frequency waveform that works especially well for being displayed on VGA. The video can also be channeled back through an audio waveform generator to create a unique sound to go along with the brilliant colors.

[James]‘s goals with this project are to generate an aesthetic feeling with his form of art and to encourage others to build upon his work. To that end, he has released the project under an open license, and the project is thoroughly documented on his project site.

There have been plenty of hacks in the past that have implemented other protocols with VGA or implemented VGA on microcontrollers, but none that have hacked the interface entirely to create something that looks like the Star Gate sequence from 2001: A Space Odyssey. We think it’s a great piece of modern art and a novel use of VGA!

Thanks for the tip, [Kyle]!

Sprite Graphics Accelerator on an FPGA

A demo running on a FPGA sprite accelerator

Graphics accelerators move operations to hardware, where they can be executed much faster. This is what allows your Raspberry Pi to display high definition video decently. [Andy]‘s latest build is a 2D sprite engine, featuring hardware accelerated graphics on an FPGA.

In the simplest mode, the sprite engine just passes commands through to the LCD. This allows for basic control. The fun part sprite mode, which allows for sprites to be loaded onto the FPGA. At that point, you can show, hide, and move the sprite. By overlapping many sprites, you something like the demo shown above.

The FPGA is from Xilinx, and uses their Block RAM IP to store the state of the sprites. The actual sprite data is contained on a 128 Mb external flash chip, since they require significant space.

The game logic runs on a STM32 Cortex M4 microcontroller which communicates with the FPGA and orders the sprites around. The FPGA then deals with generating frames and sending them to the LCD screen, freeing up the microcontroller.

If you’re wondering about the LCD itself, it’s 3.2″, 640 x 360, and taken from a Ericsson U5 Vivaz cellphone. [Andy] has a detailed writeup on reverse engineering it. After the break, he gives us a video overview of the whole system.

[Read more...]

Hyperlapse Makes Your HeadCam Videos Awesome

hyperlapse First person video – between Google Glass, GoPro, and other sports cameras, it seems like everyone has a camera on their head these days. If you’re a surfer or skydiver, that might make for some awesome footage. For the rest of us though, it means hours of boring video. The obvious way to fix this is time-lapse. Typically time-lapse throws frames away. Taking 1 of every 10 frames results in a 10x speed increase. Unfortunately, speeding up a head mounted camera often leads to a video so bouncy it can’t be watched without an air sickness bag handy. [Johannes Kopf], [Michael Cohen], and [Richard Szeliski] at Microsoft Research have come up with a novel solution to this problem with Hyperlapse.

Hyperlapse photography is not a new term. Typically, hyperlapse films require careful planning, camera rigs, and labor-intensive post-production to achieve a usable video. [Johannes] and team have thrown computer vision and graphics algorithms at the problem. The results are nothing short of amazing.

The full details are available in the team’s report (35MB PDF warning). To obtain usable data, the fisheye lenses often used on these cameras must be calibrated. The team accomplished that with the OCamCalib toolbox. Imported video is broken down frame by frame. Using structure from motion algorithms, hyperlapse creates a 3D models of the various scenes in the video. With the scenes in this virtual world, the camera can be moved and aimed at will. The team’s algorithms then pick a smooth path that follows the original cameras trajectory. Once the camera’s position is known, it’s simply a matter of rendering the final video.

The results aren’t perfect. The mountain climbing scenes show some artifacts caused by the camera frame rate and exposure changing due to the varied lighting conditions. People appear and disappear in the bicycling portion of the video.

One thing the team doesn’t mention is how long the process takes. We’re sure this kind of rendering must require some serious time and processing power. Still, the output video is stunning.

[Read more...]

THP Entry: A CPLD Video Card With VGA And NTSC


[PK] is working on a very simple video card, meant to output 640×480 VGA with a cheap CPLD. The interface will be 5 Volt SPI, meaning there’s a ton of potential here for anyone wanting put a reasonable (and cheap) display in a microcontroller project. The project has come a long way, and his latest update showcases something that has only been done once before: color NTSC with programmable logic

The brains of the outfit is a $5, 100-pin CPLD from Xilinx. Apart from that, the rest of the components are a crystal, PLL, and an almost hilarious number of resistors for the R2R ladder. The one especially unique component is the 25.056815 MHz crystal – multiply by that by two, and it’s fast enough to drive a VGA monitor. Divide the crystal by seven, it’s the 3.579545 MHz you need for an NTSC colorburst frequency. That’s VGA and NTSC in a single programmable logic project, something the one FPGA project we could find that did color NTSC couldn’t manage.

The next step in the project is designing a PCB and figuring out the code for the framebuffer. [PK] put up a demo showing off both VGA and NTSC; you can check that out below.

SpaceWrencherThe project featured in this post is an entry in The Hackaday Prize. Build something awesome and win a trip to space or hundreds of other prizes.

[Read more...]

Demystifying NTSC Color And Progressive Scan


Black and white NTSC is simple – it can, and was, done with vacuum tubes for a long, long time. Color is just weird, though. It runs at 29.976 frames per second, uses different phases of the carrier for different colors, and generally takes a while to wrap your head around. [Sagar] is doing a series on the intricacies of NTSC, and the latest post deals with color and progressive scanning versus interlacing, or as it is better known, how classic game consoles and home computers generate video.

The test bed for [Sagar]‘s video experimentations is a circuit containing an ATMega16, a 4-bit shift register, and a 14.31818 MHz clock. This clock is much faster than the 3.579545 MHz clock in an NTSC carrier frequency – exactly four times as fast – allowing the shift register to output four different phases of the carrier frequency a 0°, 90°. 180°, and 270°. Playing with some of the pins on the ATMega in the circuit results in a palette being generated on any old TV.

NTSC requires interlaced scanning, or sending an entire screen of even lines, then an entire screen of odd lines, at around 60 fields per second. The Nintendos and Segas of yesteryear didn’t bother with this, instead opting to send half the vertical resolution at double the frame rate. This is known as a progressive scan. [Sagar] found that this resulted in some image artifacts when displayed on a modern LCD, and moving back to an interlaced mode fixed the problem. All the code and files are up on the gits. If you’re feeling adventurous, this is exactly how projects like the Uzebox have created homebrew game consoles using little more than the ATMega found in [Sagar]‘s build.

The Open Hardware Driver For CRTs

driverCRTs are the king of displays for any homebrew project. They have everything – high voltages, high vacuums, X-rays, and the potential for a vector display – that makes a project exude cool. Getting an old CRT up and running, though, that’s another story. Never rear, because now there’s an Open Hardware eletrostatic CRT driver for your next display.

[Eric] designed a driver circuit that should be able to send a picture to most 2″, 3″ and some 5″ electrostatic CRTs, the kind found in ancient TVs and oscilloscopes. The 1kV power supply uses a transformer usually found in a CCFL bulb, and is able to produce several milliamps. You’ll want to keep one hand behind your back when working on this.

The driver circuit takes a 0-3.3V analog signal for deflecting the beam along the X and Y axis. The amplifier has enough bandwidth to handle NTSC video, so displaying video along with vector letters and shapes is also a possibility with this circuit. Most of the files are available on the git, with three boards available to be ordered from OSHPark.
Thanks [Mike] for the tip.

The Hovering, Holographic, Star Wars Display


While we’re still a long way off from the Star Wars telepresence holographic displays, this build over on the Projects site is the closest we’ve seen yet. Even better, it can be built in a garage for not much money.

Inside the Hoverlay are a few fans and a pair of ultrasonic atomizers that turn water into an extremely fine mist. The fans pull this vapor up through the base of the display and through simple drinking straws to create a laminar sheet of water vapor. Put a projector behind this thin sheet of vapor, and you have a display, seemingly floating in mid-air.

The base of the display can be scaled up, simply by putting several units together in a line. It’s still just a prototype – future versions will improve the stability and reduce the thickness of the fog layer – but it’s still a very cool build for a custom holographic display.

[Read more...]


Get every new post delivered to your Inbox.

Join 96,545 other followers