[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”
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?”
[Jay Kickliter] sent in his latest electronic business card. This time, his goal was to make it much cheaper so he could actually afford to give it away. He did pretty well considering the two week timeline he mentions. This card is using an MSP430 with the capsense library to light up some LEDs any time the card is handled. While he states that it is much cheaper than his last, it is still around $8 a card, so he won’t be tossing these into everyone’s hands. He does point out though that it is always helpful to have hardware to show off at a hardware interview, and an electronic business card does that job very well.
As usual, you can read more details and download the files at his blog.
For over a hundred years, good typists didn’t ‘hunt and peck’ but instead relied on keeping their fingers on the home row. This technique relies on physical buttons, but with on-screen keyboards used on tablets and other touch screen devices touch typists have a very hard time. [Zach] is working on a new project to bring a chorded keyboard to these devices called ASETNIOP.
Instead of training a typist where to place their finger – the technique used in most other keyboard replacements, ASETNIOP trains the typist which fingers to press. For example, typing ‘H’ requires the typist to press the index and middle fingers of their right hand against the touchscreen. In addition to touchscreens, ASETNIOP can be used with projection systems, Nintendo Power Glove replicas, and extremely large touchpads that include repurposed nooks and Kindles.
If you’d like to try out ASENTNIOP, there’s a tutorial that allows you to try it out on a physical keyboard as well as one for the iPad. It’s a little weird to try out but surely no more difficult to learn than a Dvorak keyboard.
We’ve all had that sinking feeling as a piece of hardware stops responding and the nasty thought of “did I just brick this thing?” rockets to the front of our minds. [Florian Echtler] recently experienced this in extremis as his hacking on the University of Munich’s Microsoft Surface 2.0 left it unresponsive. He says this is an 8,000 Euro piece of hardware, which translates to around $10,000! Obviously it was his top priority to get the thing working again.
So what’s the first thing you should do if you get your hands on a piece of hardware like this? Try to run Linux on the thing, of course. And [Florian] managed to make that happen pretty easily (there’s a quick proof-of-concept video after the break). He took a Linux kernel drive written for a different purpose and altered it to interface with the MS Surface. After working out a few error message he packaged it and called to good. Some time later the department called him and asked if his Linux kernel work might have anything to do with the display being dead. Yikes.
He dug into the driver and found that a bug may have caused the firmware on the USB interface chip to be overwritten. The big problem being that they don’t just distribute the image for this chip. So he ended up having to dump what was left from the EEPROM and rebuild the header byte by byte.
Continue reading “A tale of (un)bricking a $10k Microsoft Surface unit”
This image should look familiar to regular readers. It’s a concept that [Chris Harrison] has been working on for a while, and this hardware upgrade uses equipment which which we’re all familiar.
The newest rendition, which is named the Omnitouch, uses a shoulder-mounted system for both input and output. The functionality is the same as his Skinput project, but the goal is achieved in a different way. That used an arm cuff to electrically sense when and where you were touching your arm or hand. This uses a depth camera to do the sensing. In both cases, a pico projector provides the interactive feedback.
There’s a couple of really neat things about this upgrade. First, it has a pretty accurate multitouch capability. Second, it allows more surfaces to be used than just your arm. In fact, it can track moving surfaces and adjust accordingly. This is shown in the clip after the break when a printed document is edited in real time. Pretty neat stuff!
Continue reading “Update: using your forearms as a UI”
[Sprite_tm], a name many of you will recognize from these pages, has wasted no time in replicating the latest cool thing in a much simpler fashion. En Garde is a touch sensor that can detect up to 32 different points of contact on… whatever you use as the surface. He couldn’t sit idly by and let the Disney funded one from yesterday keep the spot light. As you can see in the video, it works pretty well. If he didn’t tell you that his can only detect up to 32 points as opposed to the 200 of the other, you probably wouldn’t even notice the difference. Of course, [Sprite_tm] also shares how you could easily beef his up to be even more precise. You can also download his source code an schematics from his site and give it a try yourself.
Continue reading “Replicating the fancy touch sensor that uses anything”