If you worked with computers back in the 1970s, there’s a good chance you used a light pen at some point: a simple input device that you’d point at the CRT screen to highlight text, choose menu options or manipulate graphic objects. Although ubiquitous in those days, the light pen lost the battle for ergonomics to the humble mouse and was all but extinct by the late 1980s. Touchscreen styluses implement a similar function today, but touching the screen somehow doesn’t feel the same as simply pointing at it.
We therefore applaud [Maciej Witkowiak]’s efforts to bring the light pen into the 21st century by building a USB interface for a Commodore 64/128 light pen. At its heart is an Arduino Micro Pro that implements the USB HID protocol to communicate with any modern computer. It connects to the classic light pen as well as to the computer’s analog display signal and uses those to calculate the delay between the video synchronization pulses and the light pen’s output. The sync pulses are extracted from the video signal by an LM1881, a sync separator chip that will be familiar to anyone who’s worked with analog video signals.
The Arduino calculates the light pen’s position based on the measured timing intervals and reports it to the computer, using the absolute positioning mode that’s also used by things like drawing pads. [Maciej] demonstrates his system in the video embedded below, in which he uses it to operate the menus on an X window system. A great success then, although there’s one catch: light pens only work on CRT displays, so you’ll need to drag one of those big glass beasts out of storage if you want to try this yourself.
With hackers and makers building custom computing devices that don’t necessarily follow conventional design paradigms, there’s been a growing demand for smaller and smaller keyboards. Many of the cyberdecks we’ve seen over the last couple of years have used so-called 60% or even 40% keyboards, and there’s been a trend towards repurposing BlackBerry keyboards for wearables and other pocket-sized gadgets. But what if you need something even smaller?
Enter this incredibly diminutive keyboard created by [TEC.IST]. With 59 keys crammed into an area scarcely larger than three US pennies, it may well be the smallest keyboard ever made. The PCB has been designed to mount directly onto the back of a Raspberry Pi Pico, which is running some CircuitPython code to read the switch matrix and act as a standard USB Human Interface Device. The board design files as well as the source code for the Pico have been released on the project’s Hackaday.io page, giving you everything you need to spin up your own teeny tiny input device.
Of course, you probably won’t be breaking any speed records when banging out text on this thing. We know from past Hackaday badges that an array of microswitches make for a functional, if somewhat unpleasant, method of text entry.
Controlling your computer with a wave of the hand seems like something from science fiction, and for good reason. From Minority Report to Iron Man, we’ve seen plenty of famous actors controlling their high-tech computer systems by wildly gesticulating in the air. Meanwhile, we’re all stuck using keyboards and mice like a bunch of chumps.
But it doesn’t have to be that way. As [Norbert Zare] demonstrates in his latest project, you can actually achieve some fairly impressive gesture control on your computer using a $10 USD PAJ7620U2 sensor. Well not just the sensor, of course. You need some way to convert the output from the I2C-enabled sensor into something your computer will understand, which is where the microcontroller comes in.
Looking through the provided source code, you can see just how easy it is to talk to the PAJ7620U2. With nothing more exotic than a switch case statement, [Norbert] is able to pick up on the gesture flags coming from the sensor. From there, it’s just a matter of using the Arduino Keyboard library to fire off the appropriate keycodes. If you’re looking to recreate this we’d go with a microcontroller that supports native USB, but technically this could be done on pretty much any Arduino. In fact, in this case he’s actually using the ATtiny85-based Digispark.
This actually isn’t the first time we’ve seen somebody use a similar sensor to pull off low-cost gesture control, but so far, none of these projects have really taken off. It seems like it works well enough in the video after the break, but looks can be deceiving. Have any Hackaday readers actually tried to use one of these modules for their day-to-day futuristic computing?
The idea early on was to leverage existing Arduino libraries to connect with a standard USB mouse, specifically, the hardware would take the form of an Arduino Mega 2560 with a USB Host Shield. There was plenty of code and examples that showed how you could read the mouse position and clicks from the Arduino, but [rehsd] still had to figure out a way to get that information into the 6502.
In the end, [rehsd] connected one of the digital pins from the Arduino to an interrupt pin on the computer’s W65C22 versatile interface adapter (VIA). Then eleven more digital pins were connected to the computer, each one representing a state for the mouse and buttons, such as MOUSE_CLICK_RIGHT and MOUSE_LEFT_DOWN.
Admittedly, [rehsd] says the mouse action is far from perfect. But as you can see in the video after the break, it’s at least functional. While the code could likely be tightened up, there’s obviously some improvements to be made in terms of the electrical interface. The use of shift registers could reduce the number of wires between the Arduino and VIA, which would be a start. It’s also possible a chip like the CH375 could be used, taking the microcontroller out of the equation entirely.
A peek inside the enclosure reveals…well, not a whole lot. All that’s hiding inside that heavy-duty plastic box is the Pi Pico and some screw down terminals that let [Alberto] easily wire up the female bulkhead connectors for the pedals themselves. Incidentally, while you could certainly make your own pedals, the ones used for this project appear to be the sort of commercially available units we’ve seen used in similar projects.
With the hardware sorted, [Alberto] just needed to write the software. While he could have taken the easy way out and hard coded everything, we appreciate that his CircuitPython script loads its configuration from a text file. This allows you to easily configure which GPIO pins are hooked up to buttons, and what key codes to associate them with. He didn’t really need to go through this much effort for his own purposes, but it makes the project far easier to adapt for others, so our hats off to him.
You might think it’s a bit early for us to be running Halloween hacks, but don’t worry. While this microcontroller-equipped doll that mimics a USB keyboard to type out messages in the creepiest way possible might seem like a gag gift you’d get after attending somebody’s bone-chilling holiday bash, creator [Jonathan] actually put it together for a friend’s wedding. So not only is it an interesting piece of hacked together hardware, but it’s also a great reminder about the importance of having a wedding registry.
Even if this seems like a rather unusual wedding gift from an outsider’s perspective (for the record, pranks involving this “haunted doll” have been a running gag between them since their school days), we can’t help but be impressed with the way [Jonathan] implemented it. An ATtiny85-powered Digispark is hidden inside the doll, along with a simple USB 2.0 hub that supposedly eases some teething issues the diminutive development board has with newer USB 3.0 ports. Through the use of V-USB, this lets the baby type out messages once plugged into the recipient’s computer.
Now he could have just stopped there, but [Jonathan] wanted this to be an interactive experience. Specifically, he wanted the baby to present the newlyweds with a personally test of sorts, and that meant taking user input. He came up with the clever user interface demonstrated in the video below, which responds to changes in the system’s “Caps Lock” state.
This platform-agnostic solution lets the user navigate the doll’s menu system by tapping a single key, although the Chromebook users out there will have to break out the Alt key to play along. It’s a neat trick for getting two-way communication going between a MCU and a computer without any client-side software, and worth filing away mentally for future non-haunted projects. It’s also worth checking out the effort [Jonathan] put into optimizing everything to fit into the chip’s paltry 6012 bytes of flash.
Incidentally, this is a good a time as any to remind readers that our Halloween Hackfest contest is live right now and taking entries until October 11th. If you’ve got any cursed bar mitzvah gifts you’ve been putting the finishing touches on, we’d love to see them.
To say that 2020 was a transformative year would be something of an understatement. The COVID-19 pandemic completely changed the way we worked, learned, and lived. Despite all those jokes about how much time people spend on their devices rather than interacting face-to-face with other humans, it turns out that when you can’t get more than a few people together in the same room, it throws our entire society into disarray.
Our community had to rethink how we congregated, and major events like HOPE, DEF CON, and even our own Hackaday Supercon, had to be quickly converted into virtual events that tried with varying degrees of success to capture the experience of hundreds or thousands of hackers meeting up in real life. While few would argue that a virtual hacker convention can ever truly replace a physical one, we learned there are undeniable benefits to embracing the advantages offered by cyberspace. If nothing else, the virtual hacker meetups of 2020 saw a far larger and more diverse array of attendees and presenters than ever before.
As we begin seeing the first rays of light at the end of the long, dark, tunnel we’ve been stuck in, it’s clear that some of the changes that COVID-19 forced on our community are here to stay. As eager as we all are to get back to the epic hackfests of old, nobody wants to close the door on all those who would be unable to attend physically now that they’ve gotten to peek behind the curtain.
With this in mind, this year’s DEF CON is being presented in both physical and virtual forms simultaneously. If you made to Las Vegas, great. If not, you can follow along through chat rooms and video streams from the comfort of your own home. Following the theme, the DC29 badge is not only a practical tool for virtual attendees, but an electronic puzzle for those who are able to bring a few of them together physically. Let’s take a closer look at this socially distanced badge and the tech that went into it.