Using Tetris Like MS Paint

Check out Samus looking boss in this pixelated image. Who would have thought of using Tetris as a canvas for these types of graphics? Coming up with the original idea of strategically clearing and leaving Tetris pieces to end up with what is shown above is hard enough. But how in the heck do you implement the algorithm that generated this programmatically?

First off, two thing should not be surprising about this. It wasn’t manually generated during normal gameplay. That would be beyond savant level. The other thing to note is that the order in which pieces occurred was not random, but strategically calculated by the algorithm. The challenge is not only to occupy and clear the correct pixels, but to make sure the correctly colored pieces remain.

You need to see the fast-motion video embedded after the break to fully appreciate the coding masterpiece at work. We’re not going to try to paraphrase how the algorithms functions, but get comfy with the link above which walks through all of the theory (in addition to supplying the code so you can try it yourself).

Continue reading “Using Tetris Like MS Paint”

Open Source GPU Released

GPLGPU

Nearly a year ago, an extremely interesting project hit Kickstarter: an open source GPU, written for an FPGA. For reasons that are obvious in retrospect, the GPL-GPU Kickstarter was not funded, but that doesn’t mean these developers don’t believe in what they’re doing. The first version of this open source graphics processor has now been released, giving anyone with an interest a look at what a late-90s era GPU looks like on the inside, If you’re cool enough, there’s also enough supporting documentation to build your own.

A quick note for the PC Master Race: this thing might run Quake eventually. It’s not a powerhouse. That said, [Bunnie] had a hard time finding an open source GPU for the Novena laptop, and the drivers for the VideoCore IV in the Raspi have only recently been open sourced. A completely open GPU simply doesn’t exist, and short of a few very, very limited thesis projects there hasn’t been anything like this before.

Right now, the GPL-GPU has 3D graphics acceleration working with VGA on a PCI bus. The plan is to update this late-90s setup to interfaces that make a little more sense, and add DVI and HDMI output. Not bad for a failed Kickstarter, right?

Reverse Engineering The Sony Ericsson Vivaz High Resolution 640 X 360 Cellphone LCD

In our opinion, reverse engineering may be one of the best ways to tease your brain. [Andy] just did that by reverse engineering the Sony Ericsson Vivaz high resolution LCD (cached copy here). In his (very) nicely written article, [Andy] explains all the steps that led him to the result shown in the picture above. He started by finding the repair manual of the Vivaz, to discover that the display could be interfaced with 8080 type parallel signals. That meant that he could use a standard microcontroller without high speed buses to interface with it, in this case the STM32F4. Next in his adventure, [Andy] ordered the appropriate connector and took a more educated guess for the onboard microcontroller. A long Google search brought up the R61523 from Renesas. So he designed his breakout board, got it produced and a few hours later a nice picture was being shown on the LCD. He even took the time to compare the original display with the clone he found on the webs, and modified his graphics library to support this display.

A GPU For An Arduino

GPU

As the creator of the Gameduino, a shield that adds a VGA port and graphics capability to any Arduino, [James] knows a little something about generating high quality video with a microcontroller. His latest project, the Gameduino 2, blows his previous projects out of the water. He’s created an Arduino shield with a built-in touchscreen that has the same graphics performance as the Quake box you had in the late 1990s.

The power behind this shield comes from a single-chip graphics solution called the FTDI EVE. This isn’t the first time we’ve heard about the FTDI EVE, but this is the first instance of a project or product using this very cool embedded graphics engine. The Gameduino 2 uses an FT800 graphics chip over an SPI connection to give a 480×272 TFT touch panel the same graphical capabilities as a Voodoo 2 graphics card. From the video, [James] is able to put thousands of sprites on a screen, as well as simple 3D animation, and extremely impressive 2D animations using only an Arduino.

While the Gameduino 2 is designed to be a game console you program yourself, we’re thinking this would be even more useful as a display for standalone projects.

An Open Source GPU

Unless you’re bit-banging a CRT interface or using a bunch of resistors to connect a VGA monitor to your project, odds are you’re using proprietary hardware as a graphics engine. The GPU on the Raspberry Pi is locked up under an NDA, and the dream of an open source graphics processor has yet to be realized. [Frank Bruno] at Silicon Spectrum thinks he has the solution to that: a completely open source GPU implemented on an FPGA.

Right now, [Frank] has a very lightweight 2D and 3D engine well-suited for everything from servers to embedded devices. If their Kickstarter meets its goal, they’ll release their project to the world, giving every developer and hardware hacker out there a complete, fully functional, open source GPU.

Given the difficulties [Bunnie] had finding a GPU that doesn’t require an NDA to develop for, we’re thinking this is an awesome project that gets away from the closed-source binary blobs found on the Raspberry Pi and other ARM dev boards.

Building Sensors For The Scratch Programming Language

[Kevin Osborn] is making it a bit easier for young programmers to write programs that interact with the physical world. The device he’s holding in the picture is an Arduino based accelerometer and distance sensor meant for the Scratch language.

Scratch is a programming language developed at MIT. It has kids in mind, and focuses on graphical building blocks. This can make it quite a bit easier to introduce youngsters to programming concepts without the roadblocks and gotchas that come with learning syntax.

As you can see in the clip after the break, [Kevin’s] Arduino sketch includes hooks that automatically pull the accelerometer and distance data into the Scratch environment. We figure his example provides everything you need to get just about any type of sensor up and running, be it a magnetometer or LDR (both of which would make a nice burglar-alarm type project). Give it a try with your own hardware and see what you can accomplish.

Continue reading “Building Sensors For The Scratch Programming Language”

Retrotechtacular: The Blit Has Given Me Access To The Power Of Multiprogramming!

We normally try to be descriptive with our titles. But when that statement pops out of the narration with notable excitement it made us chuckle. This installment of Retrotechtacular is a promotional video for the Blit. It’s a graphics-based hardware terminal for Unix systems. It’s biggest boast is the ability to run (and display on screen) several different programs at once — an activity called multiprogramming. But there is also the “digitizing mouse”. On board is a 68000 microcprocessor 256k of RAM (they call it a quarter meg), and connects via RS232. The screen is 800 by 1024; that’s right, it’s a portrait orientation.

Notable in this episode are some classic eyeglass frames, and rad synthesizer sounds for scene transitions. Whatever happened to videography technique that uses a dimwitted companion to ask that all-knowing narrator stupid questions?

Continue reading “Retrotechtacular: The Blit Has Given Me Access To The Power Of Multiprogramming!”