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.
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.
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.
[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.
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?
I always have! I don’t know why, but I like the idea of using an oscilloscope screen as a general use video display. Why not? In my case it sits on my desk full time, has a large screen area, can do multiple modes of display, and is very easy control.
Making an oscilloscope screen do your bidding is an old trick. There are numerous examples out there. Its not a finished project yet, so be nice. It is actually rather crude, using a couple parts I had on hand just on a whim. The code is a nice mixture of ArduincoreGCCish (I am sorry, still learning), and includes the following demos:
- Simple low resolution dot drawing
- A font example
- A very quickly and badly written demo of pong
The software runs on an Attiny84 micro controller clocked at 16Mhz, paired up with a Microchip MCP42100 dual 100k 8 bit digital potentiometer though the Attiny’s USI (Universal Serial Interface) pins. This is a fast, stable and accurate arrangement, but it requires sending 16 bits every time you want to change the value of one of the potentiometers so its also very piggy. I was just out to have some fun and did not have a proper 8 bit DAC. This was the closest thing outside of building one.
Join us after the break for pictures a (very) brief video and more.
[Andrew Rossignol] was curious one day and decided that he wanted to display graphics on an oscilloscope after playing around with the X and Y inputs.
[Andrew] started out with a resistor ladder on the DAC of his AVR Butterfly. He was able to to draw a line on the oscilloscope’s screen but bandwidth limitations forced him to reconsider his approach. A friend wrote a Python script to generate C code so the ports of the Butterfly can be toggled. After getting the Butterfly to generate a voltage for every non-white pixel, [Andrew] was impressed with the results so the code was modified determine the brightness of each pixel. The setup managed 10 shades of gray and careful selection of what graphics to post on the build log assured the project a little bit of blog cred.
There are a few ways to display a picture on an oscilloscope, like plugging the Hsync and Vsync into the inputs of a scope. Except for a few music visualizations, we haven’t seen a scope display generated from a microcontroller. Great work [Andrew], but we’d like to mention there’s a grayscale Hack a Day logo from way back when.
Check out a video of [Andrew]’s oscilloscope after the break.