Posts with «peripherals hacks» label

DIY Puff-Suck Interface Aims for Faster Text Input

Puff and Suck (or Sip and Puff) systems allow people with little to no arm mobility to more easily interact with computers by using a straw-like unit as an input device. [Ana] tells us that the usual way these devices are used to input text involves a screen-based keyboard; a cursor is moved to a letter using some method (joystick, mouse emulator, buttons, or eye tracking) and that letter is selected with a sip or puff into a tube.

[Ana] saw such systems as effective and intuitive to use, but also limited in speed because there’s only so fast that one can select letters one at a time. That led to trying a new method; one that requires a bit more work on the user’s part, but the reward is faster text entry. The Puff-Suck Interface for Fast Text Input turns a hollow plastic disk and a rubber diaphragm into bipolar pressure switch, able to detect three states: suck, puff, and idle. The unit works by having an IR emitter and receiver pair on each side of a diaphragm (one half of which is shown in the image above). When air is blown into or sucked out of the unit, the diaphragm moves and physically blocks one or the other emitter-receiver pair. The resulting signals are interpreted by an attached Arduino.

How does this enable faster text input? By throwing out the usual “screen keyboard” interface and using Morse code, with puffs as dots and sucks as dashes. The project then acts as a kind of Morse code keyboard. It does require skill on the user’s part, but the reward is much faster text entry. The idea got selected as a finalist in the Human-Computer Interface Challenge portion of the 2018 Hackaday Prize!

Morse code may seem like a strange throwback to some, but not only does the bipolar nature of [Ana]’s puff-suck switch closely resemble that of Morse code input paddles, it’s also easy to learn. Morse code is far from dead; we have pages of projects and news showing its involvement in everything from whimsical projects to solving serious communication needs.

A Custom Keyboard At Maximum Effort

No one loves hacked keyboards more than Hackaday. We spend most of our workday pressing different combinations of the same 104 buttons. Investing time in that tool is time well spent. [Max] feels the same and wants some personality in his input device.

In the first of three videos, he steps us through the design and materials, starting with a layer to hold the keys. FR4 is the layer of fiberglass substrate used for most circuit boards. Protoboards with no copper are just bare FR4 with holes. Homemade CNC machines can glide through FR4, achieving clean lines, and the material comes in different mask colors so customizing an already custom piece is simple. We see a couple of useful online tools for making a homemade keyboard throughout the videos. The first is a keypad layout tool which allows you to start with popular configurations and tweak them to suit your weirdest desires. Missing finger? Forget one key column. Extra digit? Add a new key column. Huge hands? More spaces between the keys. [Max] copied the Iris keyboard design but named his Arke, after the fraternal sister to Iris which is fitting since his wrist rests are removable.

In the second video, we see how the case and a custom cable are designed. One of the most beautiful features of this build is the cable with 3D-printed boots that are sized to fit ordinary pin headers. The homemade keyboard that this article is being typed on just has a piece of yellow Cat5 between the halves. When the custom cable is assembled, we see a hack revealed by accident. Twelve wires for the cable are salvaged from some ribbon cable and by cutting the ribbon straight across, every scrap of wire is the same length. No more of those unruly wires at the end or that one short one that kinks all the others. There is also a cable boot design that didn’t make the final cut but featured some secure threaded ends that are still available for download.

Another bonus hack comes from the calipers used to break wires into subsections. Check out how to make your calipers run for years on a singe battery. Keyswitch wiring is explained in the final video, shown below, which is simple enough since it is a row-and-column arrangement. The third bonus hack is when we see that classic gray ribbon “stripped” by applying a hot iron to the tip. [Max], like others, has a video about making helping hands from coolant hoses, but here he chooses the more straightforward route of putting some gummy tack on the table and mashing the header into it. Like the shortcut with the keyboard layout design, an online tool generates the firmware.

When you are ready to make your own keyboard, you will be in good hands with time-tested methods or even 3D printing. If you like the regular design, you can also overhaul an old keyboard, or update a USB device to Bluetooth.

Arduino Keyboard is Gorgeous Inside and Out

While the vast majority of us are content to plod along with the squishy chiclet keyboards on our laptops, or the cheapest USB membrane keyboard we could find on Amazon, there’s a special breed out there who demand something more. To them, nothing beats a good old-fashioned mechanical keyboard, where each key-press sounds like a footfall of Zeus himself. They are truly the “Chad” of the input device world.

But what if even the most high end of mechanical keyboards doesn’t quench your thirst for spring-loaded perfection? In that case, the only thing left to do is design and build your own. [Matthew Cordier] recently unveiled the custom mechanical keyboard he’s been working on, and to say it’s an elegant piece of engineering is something of an understatement. It may even better inside than it does on the outside.

The keyboard, which he is calling z.48, is based around the Arduino Pro Micro running a firmware generated on kbfirmware.com, and features some absolutely fantastic hand-wiring. No PCBs here, just a rainbow assortment of wire and the patience of a Buddhist monk. The particularly attentive reader may notice that [Matthew] used his soldering iron to melt away the insulation on his wires where they meet up with the keys, giving the final wiring job a very clean look.

Speaking of the keys, they are Gateron switches with DSA Hana caps. If none of those words mean anything to you, don’t worry. We’re through the Looking Glass and into the world of the keyboard aficionado now.

Finally, the case itself is printed on a CR-10 with a 0.3 mm nozzle and 0.2 mm layers giving it a very fine finish. At 70% infill, we imagine it’s got a good deal of heft as well. [Matthew] mentions that a production case and a PCB are in the cards for the future as he hopes to do a small commercial run of these boards. In the meantime we can all bask in the glory of what passes for a prototype in his world.

We’ve seen some exceptionally impressive mechanical keyboards over the years, including the occasional oddity like the fully 3D printed one and even one that inexplicably moves around. But this build by [Matthew] has to be one of the most elegant we’ve ever come across.

[Thanks to DarkSim905 for the tip]

Building a Better Kerbal Space Program Controller

If you have even the most passing interest in space and what it takes to get there, you’ve probably already played Kerbal Space Program (KSP). If you haven’t, then you should set aside about ten hours today to go check that out real quick. Don’t worry, Hackaday will still be here when you get back. Right now you need to focus on getting those rockets built and establishing a network of communication satellites so you can get out of low orbit.

For those of you who’ve played the game (or are joining us again after playing KSP for the prescribed 10, 12, 16 hours), you’ll know that the humble computer keyboard is not very well suited to jaunts through space. You really want a joystick and throttle at the absolute minimum for accurate maneuvers, but even you’ll be spending plenty of time back on the keyboard to operate the craft’s various systems. If you want the ultimate KSP control setup, you’ll need to follow in the footsteps of [Hugo Peeters] and build your own. Luckily for us, he’s written up an exceptionally well detailed guide on building KSP controllers that should prove useful even if you don’t want to clone his.

Wiring switches and buttons to the Arduino.

At the most basic level, building a KSP controller consists of hooking a bunch of switches and buttons to a microcontroller such as the Arduino or Teensy, and converting those to USB HID key presses that the game understands. This works fine up to a point, but is limited because it’s only a one-way method of communication. For his controller, [Hugo] forked KSPSerialIO, a plugin for KSP that allows bidirectional communication between the game and your controller, enabling things like digital readouts of speed and fuel levels on the controller’s panel.

Once the logistics of how you’ll talk to the game are settled, the rest is really up to the individual. The first step in building your own KSP controller is deciding what you want it to do. Are you looking to fly planes? Control a rover? Maybe you just want a master control panel for your space station. There’s a whole lot of things you can build in KSP, and the layout, inputs, and displays on your controller should ideally reflect your play style.

[Hugo] went with a fairly general purpose panel, but did spend quite a bit of extra time to get some slick LED bar graphs hooked up to display resource levels of different systems on his craft. That’s an extra step that isn’t strictly required for a build like this, but once you see it, you’re going to have a hard time not wanting to include it on your own panel. He also went through the expense of having the panel and case professionally laser cut and etched, which definitely gives it a polished feel.

We’ve covered quite a number of custom KSP controllers here at Hackaday. The overlap between KSP players and hackers seems unusually high, but of course a game that lets you build and fly contraptions of your own design does sound like something that would be right up our alley.

Jenkins Given an Industrial Stack Light for Build Reporting

When working on software development in a team environment, it’s important to know the status of your build at all times. Jenkins can display build automation info on a screen but where’s the fun in that? A popular office project is to build some kind of visual display of a project’s status, and [dkt01] has done just that with this stack light build monitor.

In this day and age of online shopping, random bits of industrial hardware are just an eBay away, so it’s easy to find some cool lamps or indicators for any project. [dkt01] sourced a standard 24V stack light off the shelf. With its green, red, and yellow indicators, its perfect for showing the current status of their build server.

The project uses an Arduino Pro Micro combined with an ENC28J60 Ethernet adapter. We used to see that chip all the time but in 2017 it’s somewhat of a classic setup since the great unwashed masses largely migrating to the ESP8266. However, for the purposes of this project, it was perfect for connecting to the wired office network (after all, you want to know the status of your build and not of your WiFi). [dkt01] even managed to get a web configuration to work despite the relatively meager resources of the ATmega32u4.

The build is cleanly executed, with the microcontroller and Ethernet hardware tucked into a 3D printed base for the stack light’s enclosure. It’s far more likely to become a permanent office fixture if it’s a tidy build without wires hanging out everywhere so a custom PCB ties everything together neatly. In another nice touch, the stack lights flash on initialization to indicate if the DHCP lease was successful, which makes troubleshooting easier. There’s an overview of all different light combinations and meanings in the video after the break.

Overall it’s a solid build with some off-the-shelf components that serves a genuine purpose. For a similar project built on a smaller scale, check out the Indictron. For something bigger, show us how you’ve learned to output your server status on the city’s traffic lights. Ask first, though.


Filed under: peripherals hacks

The Custom Clicky Shortcut Keypad

You’re not cool unless you have a mechanical keyboard. Case in point: if you were to somehow acquire an identical keyboard to the one I used to type this, it would set you back at least seven hundred dollars. Yes, it’s mechanical (Topre), and yes, I’m cooler than you. Of course, you can’t be as cool as me, but you can build your own mechanical keyboard. [Robin] is, I presume, a pretty cool dude so he built his own keyboard. It’s the amazing shortcut keyboard, and it can be programmed graphically.

The idea for this keyboard came when [Robin] was studying as an engineer. We assume this is code for wearing out the Escape key on AutoCAD, but many other software packages have the same problem. The solution to [Robin]’s problem was a shortcut keypad, a 3 by 4 matrix of Cherry switches that could be programmed for any task.

The design of this keyboard started out as an Adafruit Trellis matrix keypad. This was combined with some software written in Processing that assigned macros to each button. This was a sufficient solution, but the switches in the Adafruit trellis look squishy. These are not the right switches for someone who craves a soft snap under every fingertip. It’s not the keyboard of someone who desires the subtle thickness of laser etched PBT keycaps. The Adafruit keypad doesn’t have the graceful lines of a fully sculpted set of keycaps. Oh my god, it’s doubleshot.

[Robin]’s completed keyboard has gone through a few revisions, but in the end, he settled on PCB-mounted switches and a very clever 3D printed standoff system to hold an Arduino Pro Micro in place. The enclosure, too, is 3D printed, and the end result is a completely custom keyboard that’s perfect for mashing key combos.

You can check out a video of this keyboard in action below.


Filed under: Arduino Hacks, peripherals hacks

Tiny Morse Code USB Keyboard

We’ve featured quite a few of [mitxela]’s projects here in the past, and many of them have the propensity to be labelled “smallest”. His Morse Code USB Keyboard Mk II adds to that list. It’s a Saturday afternoon project, with a few parts slapped onto a piece of perf-board, that allows using a Morse key as a USB keyboard. This project isn’t new or fresh, but we stumbled across it while trying to figure out a use for a Morse key lying in the author’s bin of parts. You can practise transmitting, by reading text and typing it out on the key, and then look it up on your computer to see if you made any mistakes. Or you can practise receiving, by asking a friend to punch it out for you. Either way, it’s a great way to hone your skills and prepare for your radio operators license exam.

The project is a follow up to his earlier one where he hooked up the Morse key via a RS-232 — USB converter directly to a computer and let the code do all the work. That turned out to be a very resource hungry, impractical project and made him do it right the next time around. The hardware is dead simple. An ATtiny85, a piezo buzzer, some decoupling capacitors, and a few resistors and zeners to allow a safe USB interface. The design accommodates a straight key, but there is one spare pin left over in the ATtiny to allow for iambic or sideswiper keys too. There is no speed adjustment, which is hardcoded at the moment. That isn’t very user friendly, and [mitxela] suggests adding a speed potentiometer to that last remaining pin on the ATtiny. This would prevent use of iambic/sideswiper keys. Or, you could use the RST pin on the ATtiny as a (weak) IO. The RST pin can read analog values between 5V and 2.5V, and will reset when voltage falls below 2.2V. Or just use another microcontroller as a last resort.

For the USB interface, [mitxela] is using the V-USB library after wasting some time trying to reinvent the wheel. And since this is designed to work as a HID, there are no drivers required – plug it in, and the OS detects it as a keyboard. He’s borrowed code from the EasyLogger project to use the internal oscillator and help free up the IO pins. And to detect the characters being typed, his code uses a long string of compare statements instead of a dictionary lookup. Writing that code was tedious, but it makes the identification quicker, since most characters can be identified in less that five comparisons (one dit = E, two dits = I, three dits = S and so on). This “tree” makes it easier to figure it out.

If you’d like to look up some of his other “tiny” projects, check out The smallest MIDI synthesizer, Smallest MIDI synth, again! and the ATtiny MIDI plug synth.


Filed under: peripherals hacks

MalDuino — Open Source BadUSB

MalDuino is an Arduino-powered USB device which emulates a keyboard and has keystroke injection capabilities. It’s still in crowdfunding stage, but has already been fully backed, so we anticipate full production soon. In essence, it implements BadUSB attacks much like the widely known, having appeared on Mr. Robot, USB Rubber Ducky.

It’s like an advanced version of HID tricks to drop malicious files which we previously reported. Once plugged in, MalDuino acts as a keyboard, executing previous configured key sequences at very fast speeds. This is mostly used by IT security professionals to hack into local computers, just by plugging in the unsuspicious USB ‘Pen’.

[Seytonic], the maker of MalDuino, says its objective is it to be a cheaper, fully open source alternative with the big advantage that it can be programmed straight from the Arduino IDE. It’s based on ATmega32u4 like the Arduino Leonardo and will come in two flavors, Lite and Elite. The Lite is quite small and it will fit into almost any generic USB case. There is a single switch used to enable/disable the device for programming.

The Elite version is where it gets exciting. In addition to the MicroSD slot that will be used to store scripts, there is an onboard set of dip switches that can be used to select the script to run. Since the whole platform is open sourced and based on Arduino, the MicroSD slot and dip switches are entirely modular, nothing is hardcoded, you can use them for whatever you want. The most skilled wielders of BadUSB attacks have shown feats like setting up a fake wired network connection that allows all web traffic to be siphoned off to an outside server. This should be possible with the microcontroller used here although not native to the MalDuino’s default firmware.

For most users, typical feature hacks might include repurposing the dip switches to modify the settings for a particular script. Instead of storing just scripts on the MicroSD card you could store word lists on it for use in password cracking. It will be interesting to see what people will come up with and the scripts they create since there is a lot of space to tinker and enhanced it. That’s the greatness of open source.

You can watch the prototype in action in the video:


Filed under: Arduino Hacks, peripherals hacks, security hacks

Quickie USB Keyboard Device

There are a ton of applications that we use that can benefit from keyboard shortcuts, and we use ’em religiously. Indeed, there are some tasks that we do so often that they warrant their own physical button. And the only thing cooler than custom keyboards are custom keyboards that you’ve made yourself.

Which brings us to [Dan]’s four-button Cherry MX USB keypad. It’s not really all that much more than four keyswitch footprints and an AVR ATmega32u4, but that plus some software is all you really need. He programs the Arduino bootloader into the chip, and then he’s using the Arduino Leonardo keyboard libraries. Bam! Check out the video below.

We see this design much more as a demo or collection of building-blocks than necessarily a one-size-fits-all solution. You might need five buttons, or want a different layout, or… It’s all open-source, so go nuts. And you’re not limited to key-clicks either — mouse buttons or even multiple scripted actions are within easy reach.

Building a special-function USB keypad or gaming device used to be hard work. But today between hardware and software design availability, it’s child’s play. Whether you need a footboard, a single-handed chording keyboard, or even just to update an old typewriter, the ability to control the input device that we use for eight hours per day is liberating. Experiment!


Filed under: Arduino Hacks, peripherals hacks

USB Volume Control

If you buy expensive computer speakers, they often have a volume knob you can mount somewhere on your desk so you aren’t dependent on the onboard volume control. [Kris S] decided to build his own version of the remote volume control. Not surprisingly, it uses an Arduino-compatible Digispark board and a rotary controller. The Digispark (that [Kris S] bought for $2) is compatible with the Adafruit Trinket. This is key because the Trinket libraries are what make it easy to send media keys over the USB (using the HID interface) to control the volume.

Really, though, the best part of the build is the good looking knob made out of a pill bottle (see the video below). The micro Digispark is small enough to fit in the lid of the pill bottle, and some wax and pellets add some heft to the volume control.

The standard Arduino library has trouble sending multimedia keys, but in a previous post I built a gesture-based volume control that managed to pull it off.  We’ve also covered a similar volume control in the past. That one is also very good looking, but was a more complicated build than what [Kris S] pulled off here.


Filed under: Arduino Hacks, peripherals hacks