Foot Pedal Ups Vim Productivity, Brings Ergonomic Benefits

December 16, 2022 by Lewin Day 52 Comments

Vim is the greatest or the worst text editor of all time, depending on the tribe you’re in. Either way, members of both camps can appreciate this build from [Chris Price], which uses a foot pedal to ease operations for the user.

The basic concept was to use a pedal to enable switching between normal and insert modes. In Vim’s predecessor, vi, switching modes was easy, with the ESC key located neatly by the Q on the keyboard of the ADM-3A terminal. On modern keyboards, though, it’s a pain, and so a foot pedal is a desirable solution. In the Vim world, it’s referred to as a “Vim clutch.”

The build used a cheap pedal switch sourced from eBay, into which a Raspberry Pi Pico was installed. The Pico was hooked up to the switch contacts, and programmed to act as a USB HID device. When the pedal is pressed down, the Pico sends an “i” keypress to enter Vim’s insert mode. Releasing the pedal has the Pico send a “ESC” keypress to return to normal mode.

Those that use Vim on a regular basis would likely appreciate the productivity improvements of such a device. Plus, there’s some ergonomic benefits to not having to strain one’s hand over to reach the ESC key. Of course, it’s an old-school solution, but there’s still something so compelling and next-level about having a foot pedal hooked up to one’s dev rig.

A PCB with an Arduino Micro Pro, RCA connectors and a sub-D connector

Odd Inputs And Peculiar Peripherals: Using A Commodore Light Pen On A Modern(ish) Computer

June 11, 2022 by Robin Kearey 8 Comments

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.

We’ve featured the Commodore light pen before in this odd gaming input device. A similar device built with a discrete LED matrix is a good illustration of the light pen’s working principle.

Continue reading “Odd Inputs And Peculiar Peripherals: Using A Commodore Light Pen On A Modern(ish) Computer” →

Raspberry Pi Pico Gets A Tiny Keyboard On Its Back

January 10, 2022 by Tom Nardi 25 Comments

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.

The Pi Pico’s castellated pads make attaching the PCB a snap.

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.

Continue reading “Raspberry Pi Pico Gets A Tiny Keyboard On Its Back” →

Low-Cost Computer Gesture Control With An I2C Sensor

November 12, 2021 by Tom Nardi 6 Comments

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?

Continue reading “Low-Cost Computer Gesture Control With An I2C Sensor” →

Arduino Brings USB Mouse To Homebrew Computer

October 18, 2021 by Tom Nardi 2 Comments

When building your own homebrew computer, everything is a challenge. Ultimately, that’s kind of the point. If you didn’t want to really get your hands dirty with the nuts and bolts of the thing, you wouldn’t have built it in the first place. For example, take the lengths to which [rehsd] was willing to go in order to support standard USB mice on their 6502 machine.

Code for mapping mouse movement to digital output.

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.

From classic breadboard builds to some impressively practical portable machines, we’ve seen our fair share of 6502 computers over the years. Despite the incredible variation to be found in these homebrew systems, one thing is always the same: they’re built by some of the most passionate folks out there.

Continue reading “Arduino Brings USB Mouse To Homebrew Computer” →

Raspberry Pi Pico Makes For Expeditious Input Device

September 29, 2021 by Tom Nardi 28 Comments

With its copious number of GPIO pins and native USB, the Raspberry Pi Pico is arguably the ideal microcontroller for developing your own platform agnostic USB Human Input Devices. But you don’t have to take our word for it. Check out how quickly the $4 USD board allowed [Alberto Nunez] to put together a pair of foot pedals for his computer.

Wiring doesn’t get much easier than this.

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.

If you’re looking for a bit more inspiration, our very own [Kristina Panos] put together a Python-powered macro foot stool that you can put under your desk for rapid fire keyboard shortcuts. Plus you can stand on it to reach the top shelf, if need be.

Spooky USB Baby Types Out Messages From Beyond

September 8, 2021 by Tom Nardi 3 Comments

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.

Soldering the Digispark to a cheap USB hub keeps newer computers happy.

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.

Continue reading “Spooky USB Baby Types Out Messages From Beyond” →