Making Embedded GUI’s Without Code

When the 4D Systems display first arrived in the mail, I assumed it would be like any other touch display – get the library and start coding/debugging and maybe get stuff painted on the screen before dinner. So I installed the IDE and driver, got everything talking and then…it happened. There, on my computer screen, were the words that simply could not exist –  “doesn’t require any coding at all”.

I took a step back, blinked and adjusted my glasses. The words were still there. I tapped the side of the monitor to make sure the words hadn’t somehow jumbled themselves together into such an impossible statement. But the words remained…   doesn’

Continue reading “Making Embedded GUI’s Without Code”

Interfacing with the HTC Desire Display and its Touch Panel

Part of [Linas]’ submission to last year’s Cypress Smarter Life Challenge involved using the HTC Desire display and its touch screen. This particular phone includes a full-color active-matrix OLED (AMOLED) display that has a 3.7″ diagonal and a 480×800 resolution, resulting in a 252ppi pixel density. Using a MSO2024B oscilloscope, [Linas] originally started his adventure with the touchscreen by sniffing the I2C signals. As some math was required to extract the data, he later found the HTC Desire source code and included it on his STM32F429 (so much for reverse engineering!).

After spending many hours searching for the AMOLED display and controller datasheets, [Linas] resorted to pay a company to get the resources he needed. He produced a custom-made PCB to provide the display with the required voltages, as well as offering a 0.1″ connector to interface with it. A RGB565 interface is used to communicate with the screen so only 65k out of the 16 million colors are used. You may download all the program files and datasheets in [Linas] write-up.

Camera-based touchscreen input via an FPGA


[Chonggang Li] wrote in to share a link to the final project he and [Ran Hu] built for their embedded systems class. It’s called Piano Hero and uses an FPGA to implement a camera-based touch screen system.

All of the hardware used in the project is shown above. The monitor acts as the keyboard, using an image produced by the FPGA board to mark the locations of each virtual key. It uses a regular VGA monitor so they needed to find some way to monitor touch inputs. The solution uses a camera mounted above the screen at an obtuse angle. That is to say, the screen is tilted back just a bit which allows the images on it to be seen by the camera. The FPGA board processes the incoming image, registering a key press when your finger passes between the monitor and the camera. This technique limits the input to just a single row of keys.

This should be much simpler than using a CCD scanner sensor, but that one can track two-dimensions of touch input.

Continue reading “Camera-based touchscreen input via an FPGA”

MSP430 touchscreen piano


[Rohit Gupta] wrote in to share this touchscreen piano project he built around the TI Launchpad. It provided a way for him to explore using a resistive digitizer found on a lot of mobile devices. These are simply stuck to the top of LCD screens and replacements are inexpensive, but salvaging one from old hardware is an option as well.

The first thing he did was to test the four outputs of the digitizer with his multimeter. Logging the changing resistance will help make sure you’re reading the correct wires and are able to zero in the settings before you start coding. [Rohit] uses the ADC on the MSP430 chip to read from the screen. He went with the algorithm from one of TI’s app notes to convert the readings in to X and Y coordinates.

He separated the screen into seven columns, each generating a different tone. Touching higher or lower on that column will alter the pitch of the note produced. You can hear an example of this in the demo after the jump.

Continue reading “MSP430 touchscreen piano”

Ask Hackaday: Are we close to reinventing the keyboard for touchscreens?


We mourn the loss of the physical keyboard with the advent of tablets. After all, we do a bit of typing getting all of these features posted throughout the week. And we kind of blame tablets for the decline of the netbook industry (we still use a Dell Vostro A90 when not at home). But we’re trying to keep an open mind that we may not need a physical keyboard anymore. If someone can come up with an innovative alternative to the Qwerty layout that we are able to learn and can use with speed and without physical strain we’ll be on board. Our question is,  do you think we are close to a screen typing breakthrough?

This question came to mind after seeing the Minuum keyboard shown above. It compresses all of the rows of a Qwerty into a single row, monopolizing less screen space than conventional smartphone input methods. The demo video (embedded after the break) even shows them hacking the concept into a distance sensor and using a graphite-on-paper resistor. Pretty cool. But what happens when you type a word not in the dictionary, like this author’s last name?

You can actually try out the Minuum style thanks to [Zack’s] in-browser demo hack. He’s not affiliated with Minuum, but has done quite a bit of alternative keyboard input work already with his ASETNIOP chorded typing project. It’s another contender for changing how we do things.

Continue reading “Ask Hackaday: Are we close to reinventing the keyboard for touchscreens?”

Enabling an unused touchscreen overlay on a consumer LCD


When [Andrei] first got his Raspberry Pi he wanted to make it a standalone computer right away. This means the normal input devices like a mouse and keyboard, but also some type of display. To avoid waiting for shipping he ended up using a cheap vehicle backup camera screen from the local big box store. It worked great, and recently he decided he would try to convert it to run off of 5V power to simplify his setup. While snooping around inside the device he discovered an unused resistive touch overlay and figured out how to get it to work.

What tipped him off is the small four-conductor connector which wasn’t hooked up to anything. He carefully soldered wires onto the flexible circuit traces, then generously covered them in hot glue to help prevent movement from breaking the rigid connection. To get this working you need to measure the resistance between the conductors. Most of the time we figure the RPi GPIO header can be used directly, but for this task an intermediary is necessary. [Andrei] went with a small Arduino clone board. A bit of trial and error was all it took to get the connections right and to iron out the code which translates the values into coordinates.

Building a touchscreen XBMC setup with the Raspberry Pi


[Andrei Istodorescu] has been hard at work building a 7″ touch-screen rig which runs XBMC. It may be upside-down, but the Raspberry Pi board which is front and center is still easily recognizable. There’s a lot of stuff connected to it in order to pull this off, and even more software configuration. But as you can see in the clip after the break he did get it working!

The screen is an eGalaxy 7″ touch sensitive module he picked up on eBay. It sounds like it was meant for a backup camera in the dashboard of a car. He compiled his own Linux kernel to add support for the screen. It uses HDMI for the video interface with the driver board, and the touchscreen connects to one of the USB ports. The rest of the setup involves compiling XBMC with touchscreen support and calibrating the screen to accurately sense input.

Continue reading “Building a touchscreen XBMC setup with the Raspberry Pi”